Introduction
Let us check the situation as you went to a supermarket and ordered something. After the purchase, the cashier summarized the amount, and you did have not much of the amount at that time. But you can take it from an ATM counter (I am saying a situation where credit/debit card payments are not possible. Only ready cash wants to be paid.). So you just leave the shop to take the money, and the shopkeeper wants to keep your bill as a pending one and should deal with the billing of other customers. So keeping a bill or anything as a pending one is our core discussion. You can keep the items in memory and can also easily forget them when a power failure occurs. So everything should be persisted in a file form is the best option.
What is Serialization?
Serialization is doing nothing but keeping the state of an object in the form of a file. So you can access large amounts of data through your application and also keep the object containing data in a file format. So you can carry your whole data along with you in a simple file format and can also access it whenever you wish. Saving an object's state is termed serialization, and from the saved format, regaining the object's state is known as deserialization. In the sample code, along with this article, I saved the particular bill item in a serialized form and then deserialized it for later use. Remember that serialization has the format of XML or binary. If you use the XML format, it stores everything in a text format and can be readable. But the binary format is a secure one and is used in this article also.
Create a new c# Windows application and add a new class named Item to that project. This Item class is the object we are going to persist. Item class is used to store the items of a bill that want to be saved as a pending bill. Below is the structure of the class Item.
Example
public class Item
{
private string itemName;
private string itemId;
private double itemPrice;
private long itemQuantity;
private double netAmount;
public Item()
{
ItemName = "";
ItemPrice = 0.00;
ItemQuantity = 0;
NetAmount = 0.00;
}
public string ItemName
{
get { return itemName; }
set { itemName = value; }
}
public string ItemId
{
get { return itemId; }
set { itemId = value; }
}
public double ItemPrice
{
get { return itemPrice; }
set { itemPrice = value; }
}
public long ItemQuantity
{
get { return itemQuantity; }
set { itemQuantity = value; }
}
public double NetAmount
{
get { return netAmount; }
set { netAmount = value; }
}
}
As you can see, there are 5 properties declared in the class to store the items as their names describe. The storing operation will take place in a win form. But the most important thing want to notice is the [Serializable] attribute. Every object you want to serialize should at least decorate this attribute.
In the front end, you have 4 text boxes for entering values for the name, quantity, price, and net amount of a particular item. If you click on the Save button, nothing special will happen. Just saving the record. But our aim is the button for saving the pending bills. When u click that button, an object of the Item class will create and set the object properties with the corresponding values of the fields. The ItemId property will be set by creating a new GUID, as the object will save using this value. Now and now, we want to save this object in a file format. Just look at the code below.
Example
// Create a file stream in which the object will be stored
FileStream fstream = File.Create(SERIALIZED_FILE_PATH + @"\" + objItem.ItemId);
// Create a BinaryFormatter to store the object in binary format
BinaryFormatter bf = new BinaryFormatter();
// Serialize the object and bind the file stream with the BinaryFormatter
bf.Serialize(fstream, objItem);
// Close the file stream and release resources
fstream.Close();
fstream = null;
bf = null;
We are going to store the object in a file, so first, create a FileStream object using the static method Create of File Class. The argument is the full path name of the file. After setting this, we want to create an object of BinaryFormatter, as we are going to store the object in a binary format. Use the Serialize() method of BinaryFormatter to serialize the particular object. Arguments are the file stream we created and the object that we want to serialize. If you browse to the location, you can see the file with an extension of ".dat" (you can use your own extension). There is a list view in the form to view all object data serialized. For that, we are using the Deserialize() method of BinaryFormatter. As Deserialize() returns an object type for occupying all types of data, we need to cast the returned value. Just look at the code below.
Example
FileStream fstream = File.OpenRead(serializedFiles.GetValue(fileIndex).ToString());
BinaryFormatter bf = new BinaryFormatter();
Item ser = (Item)bf.Deserialize(fstream);
string[] itemValues = { ser.ItemName, ser.ItemPrice.ToString(), ser.ItemQuantity.ToString(), ser.NetAmount.ToString(), ser.ItemId.ToString() };
itemsListView.Items.Add(new ListViewItem(itemValues));
You want to select an item from the list view to save it as a normal paid bill. Then click the Save button to finish the process, as it saves the values to the database and deletes the particular pending bill from the location.
So the basic concept is that every pending item will be stored as a serialized object and you can select any saved object at any time and convert it to a paid bill. This is really a concept, and you can design it in your own way. Please check the code along with this.