I'm to implement a new member application without the use of databases. I'm planning to create a class to define each member, with fields defining name, department etc. I wish to save a list of these members into a file (not plain text). So my question is to how to save a class object into a file ?
Thanks in advance :)
I would suggest doing JSON or XML serialization and then encrypting the contents with some algorithm. I wouldn't go with binary serialization because it's not very friendly when you need to change the assembly version.
I am using the following code together with Newtonsoft.Json (you can get it on NuGet) to accomplish this:
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Newtonsoft.Json;
class SecureJsonSerializer<T>
where T : class
{
private readonly string filePath;
private readonly ICryptoTransform encryptor;
private readonly ICryptoTransform decryptor;
private const string Password = "some password";
private static readonly byte[] passwordBytes = Encoding.ASCII.GetBytes(Password);
public SecureJsonSerializer(string filePath)
{
this.filePath = filePath;
var rmCrypto = GetAlgorithm();
this.encryptor = rmCrypto.CreateEncryptor();
this.decryptor = rmCrypto.CreateDecryptor();
}
private static RijndaelManaged GetAlgorithm()
{
var algorithm = new RijndaelManaged();
int bytesForKey = algorithm.KeySize / 8;
int bytesForIV = algorithm.BlockSize / 8;
algorithm.Key = key.GetBytes(bytesForKey);
algorithm.IV = key.GetBytes(bytesForIV);
return algorithm;
}
public void Save(T obj)
{
using (var writer = new StreamWriter(new CryptoStream(File.Create(this.filePath), this.encryptor, CryptoStreamMode.Write)))
{
writer.Write(JsonConvert.SerializeObject(obj));
}
}
public T Load()
{
using (var reader = new StreamReader(new CryptoStream(File.OpenRead(this.filePath), this.decryptor, CryptoStreamMode.Read)))
{
return JsonConvert.DeserializeObject<T>(reader.ReadToEnd());
}
}
}
Sounds like you want the BinaryFormatter. This saves to a non-readable binary file. One of the major benefits of it over XmlSerialization (for example) is that your properties don't need to be public.
However I would personally like to dissuade you from this idea. I've been down this road myself and while its easy in the short term, in the long run there is a lot of pain on the way.
You will have massive issues with versioning. Whenever you want to update any object (say, add a new property) you'd have to convert all of the files.
Even worse if you want to do this within the same application you'll need both definitions available at the same time. This leads to absurdist class definitions such as:
// my original object
class SavedObject
{
public string Data{get;set}
}
// needed to add a field for last edit
class SavedObject2
{
public DateTime LastEdit{get;set;}
public SavedObject2(SavedObject so){}
}
// need a small restructure so we can now have multiple datas
// 'data' is now obsolete
class SavedObject3
{
public List<string> DataList{get;set;}
public SavedObject3(SavedObject2 so){}
}
Serialising as a means of persistence is only good in two scenarios. One where you know the data will never change in definition (incredibly rare) and: Two where you are just saving the data in a primitive fashion (for example just a collection of strings that code then converts into classes).
I would seriously consider using a database. If you're disliking the administrative chores that come with most production databases then consider using Sqlite, it's small, portable and very easy to embed within an application.
Well first you could serialize your class to json using this tool: Json Net
Second find any encryption tool from your preferences, there are a lot, here is and example : Encode to 64
After that you can save your file:
System.File.WriteAllText(@"C:\file.dat","encripted string");
