public override void Append <Y>(ListSerializable <T> listElements, string path, string ElementsName = "")
{
if (!File.Exists(path))
{
throw new FileNotFoundException(path + " not found");
}
if (string.IsNullOrEmpty(ElementsName))
{
throw new ArgumentNullException(nameof(ElementsName) + " is null or empty");
}
_Path = path;
string text = _XmlSerializer.SerializeList <Y>(listElements);
///get just necesserary element
XDocument docTemp = XDocument.Parse(text);
XElement parent = docTemp.Descendants(ElementsName).First();
List <XElement> elementToWrite = parent.Elements().ToList();
///read file
Loader loaderXml = new Loader();
string message = loaderXml.LoadXMLFile(path);
if (string.IsNullOrEmpty(message))
{
XDocument doc = loaderXml.GetDocument();
XElement element = doc.Element(ElementsName);
element.Add(elementToWrite);
Save(doc);
}
}
/// <summary>
/// read line and create object T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="fileName"></param>
/// <returns>Liste of T, one by line</returns>
public ListSerializable <T> read <Y>(string filePath) where Y : ListSerializable <T>
{
ListSerializable <T> elements = (Y)Activator.CreateInstance(typeof(Y));
using (var reader = new StreamReader(filePath))
{
int count = 0;
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (count == 0 && HasHeader)
{
CheckCorrectHeader(line);
}
else
{
IStandardSerializer <T> serializer = new CsvSerializer <T>(Separator);
Serializable element = serializer.Deserialize(line);
elements.Add((T)element);
}
count++;
}
}
return(elements);
}
internal static void Append <Y>(IStandardSerializer <T> serializer, T element, string path) where Y : ListSerializable <T>
{
string content = FileReader.Read(path);
ListSerializable <T> list = (Y)Activator.CreateInstance(typeof(Y));
try
{
//check if it is a list
list = serializer.DeserializeList <Y>(content);
if (list.Count == 0)
{
//maybe it's an object
list.Add(serializer.Deserialize(content));
}
}
catch
{
//else is just an object
list.Add(serializer.Deserialize(content));
}
list.Add(element);
string text = serializer.SerializeList <Y>(list);
FileWriter.Write(text, path);
}
public void GenericReaderCsv()
{
ListSerializable <User> users = new UserList();
users.Add(new User("Toto", "Titi"));
users.Add(new User("Tata", "Roro"));
IWriter <User> write = new CsvWriter <User>(';', new StringList {
"Name", "Firstname"
});
write.Write <UserList>(users, CsvFile);
IGenericReader <User> reader = new CsvReader <User>(';', new StringList {
"Name", "Firstname"
});
ListSerializable <User> usersToCompare = reader.read <UserList>(CsvFile);
Assert.IsNotNull(usersToCompare);
Assert.AreEqual(users[0].Firstname, usersToCompare[0].Firstname);
Assert.AreEqual(users[0].Name, usersToCompare[0].Name);
Assert.AreEqual(users[1].Firstname, usersToCompare[1].Firstname);
Assert.AreEqual(users[1].Name, usersToCompare[1].Name);
}
public void writeExcelFile()
{
ListSerializable <User> users = new UserList();
users.Add(new User("Toto", "Titi"));
users.Add(new User("Tata", "Roro"));
IWriter <User> write = new ExcelWriter <User>("Users", new StringList {
"Name", "Firstname"
});
write.Write <UserList>(users, ExcelFile);
IReader <User> reader = new ExcelReader <User>("Users", new StringList {
"Name", "Firstname"
});
ListSerializable <User> usersToCompare = reader.read <UserList>(ExcelFile);
Assert.IsNotNull(usersToCompare);
Assert.AreEqual(users[0].Firstname, usersToCompare[0].Firstname);
Assert.AreEqual(users[0].Name, usersToCompare[0].Name);
Assert.AreEqual(users[1].Firstname, usersToCompare[1].Firstname);
Assert.AreEqual(users[1].Name, usersToCompare[1].Name);
}
public override void Append <Y>(ListSerializable <T> listElements, string path, string ElementsName = "")
{
ExcelReader <T> reader = new ExcelReader <T>(_WorkSheetName);
ListSerializable <T> list = reader.read <Y>(path);
list.AddRange(listElements);
Write(list, path);
}
public override void Append <Y>(ListSerializable <T> listElements, string path, string ElementsName = "")
{
if (File.Exists(path))
{
string text = _JsonSerializer.SerializeList <Y>(listElements);
JArray root = (JArray)JsonConvert.DeserializeObject(File.ReadAllText(path));
JArray parentList = JArray.Parse(text);
foreach (var item in parentList.Children())
{
root.Add(item);
}
FileWriter.Write(root.ToString(), path);
}
else
{
throw new FileNotFoundException(path + "not found");
}
}
public ListSerializable <T> read <Y>(string filePath) where Y : ListSerializable <T>
{
Loader loader = new Loader();
string errorMessage = loader.LoadXMLFile(filePath, _namespaceUri, _pathXsdFile);
if (string.IsNullOrEmpty(errorMessage))
{
XDocument doc = loader.GetDocument();
//test if file is a list of elements
XElement element = doc.Element(_tagElements);
IStandardSerializer <T> serializer = new XmlSerializer <T>();
if (element != null)
{
string result = string.Concat(element);
return(serializer.DeserializeList <Y>(result));
}
else
{
//test if file contains only one element
element = doc.Element(_typeElement);
if (element != null)
{
string result = string.Concat(element);
ListSerializable <T> elements = (Y)Activator.CreateInstance(typeof(Y));
elements.Add(serializer.Deserialize(result));
return(elements);
}
else
{
throw new ArgumentException("File not contains this type of serializable object");
}
}
}
else
{
throw new InvalidOperationException(errorMessage);
}
}
public void GenericReaderJson()
{
ListSerializable <User> users = new UserList();
users.Add(new User("Toto", "Titi"));
users.Add(new User("Tata", "Roro"));
IWriter <User> write = new JsonWriter <User>();
write.Write <UserList>(users, JsonFile);
IGenericReader <User> reader = new JsonReader <User>();
ListSerializable <User> usersToCompare = reader.read <UserList>(JsonFile);
Assert.IsNotNull(usersToCompare);
Assert.AreEqual(users[0].Firstname, usersToCompare[0].Firstname);
Assert.AreEqual(users[0].Name, usersToCompare[0].Name);
Assert.AreEqual(users[1].Firstname, usersToCompare[1].Firstname);
Assert.AreEqual(users[1].Name, usersToCompare[1].Name);
}
public void GenericReaderDefaultWithBasicSerializer()
{
ListSerializable <User> users = new UserList();
users.Add(new User("Toto", "Titi"));
users.Add(new User("Tata", "Roro"));
IWriter <User> write = new DefaultWriter <User>(new UserBasicSerializer());
write.Write <UserList>(users, CsvFile);
IGenericReader <User> reader = new DefaultReader <User>(new UserBasicSerializer());
ListSerializable <User> usersToCompare = reader.read <UserList>(CsvFile);
Assert.IsNotNull(usersToCompare);
Assert.AreEqual(users[0].Firstname, usersToCompare[0].Firstname);
Assert.AreEqual(users[0].Name, usersToCompare[0].Name);
Assert.AreEqual(users[1].Firstname, usersToCompare[1].Firstname);
Assert.AreEqual(users[1].Name, usersToCompare[1].Name);
}
public override void Append <Y>(ListSerializable <T> listElements, string path, string ElementsName = "")
{
string text = _CsvSerializer.SerializeList <Y>(listElements);
if (_CsvSerializer.HasHeader)
{
Type type = typeof(T);
var bindingFlags = BindingFlags.Instance |
BindingFlags.NonPublic |
BindingFlags.Public;
FieldInfo[] listValues = type.GetFields(bindingFlags);
if (listValues.Length > 0)
{
StringList listValuesName = new StringList(listValues.Select(value => value.Name).ToList());
string header = listValuesName.Join(_CsvSerializer.Separator);
StringList linesInfile = new CsvReader <T>(_CsvSerializer.Separator).readLine(path, true);
if (linesInfile.First() != header)
{
//add header and rewrite file
StringBuilder sb = new StringBuilder();
sb.AppendLine(header);
foreach (string line in linesInfile)
{
sb.AppendLine(line);
}
FileWriter.Write(sb.ToString(), path);
}
if (text.Contains(header))
{
//remove header if exist in text to append
text = text.Remove(0, header.Length + 2); //2 for \r\n
}
}
}
FileWriter.Append(text, path);
}
public string SerializeList <Y>(ListSerializable <T> listObjects) where Y : ListSerializable <T>
{
return(SerializeList((Y)listObjects));
}
public override void Append <Y>(ListSerializable <T> listElements, string path, string ElementsName = "")
{
string text = _DefaultSerializer.SerializeList <Y>(listElements);
FileWriter.Append(text, path);
}
public void Write <Y>(ListSerializable <T> listElements, string path) where Y : ListSerializable <T>
{
Write((Y)listElements, path);
}
public abstract void Append <Y>(ListSerializable <T> listElements, string path, string ElementsName = "") where Y : ListSerializable <T>;
public ICollection <object[]> SerializeList <Y>(ListSerializable <T> listObjects) where Y : ListSerializable <T>
{
return(SerializeList((Y)listObjects));
}
