havdone's memory

Posted at

☆

By Bipin Joshi May 14, 2001

Introduction

In simple words serialization is a process of storing the object instance to a disk file. Serialization stores state of the object i.e. member variable values to disk. Deserialization is reverse of serialization i.e. it's a process of reading objects from a file where they have been stored. In this code sample we will see how to serialize and deserialize objects using C#.

Namespaces involved

Following namespaces are involved in serialization process :

System.Runtime.Serialization

System.Runtime.Serialization.Formatters.Binary

Example 1

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public class SerialTest
{
public void SerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Create);
BinaryFormatter b=new BinaryFormatter();
b.Serialize(s,c);
s.Close();
}
public void DeSerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Open);
BinaryFormatter b=new BinaryFormatter();
c=(ClassToSerialize)b.Deserialize(s);
Console.WriteLine(c.name);
s.Close();
}
public static void Main(string[] s)
{
SerialTest st=new SerialTest();
st.SerializeNow();
st.DeSerializeNow();
}
}
public class ClassToSerialize
{
public int age=100;
public string name="bipin";
}

Explanation

Here we have our own class named ClassToSerialize. This class has two public valiables name and age with some default values. We will write this class to a disk file (temp.dat) using SerializeTest class.

SerializeTest class has two methods SerializeNow() and DeSerializeNow() which perform the task of serialization and deserialization respectively.

The general steps for serializing are :

Create an instance of File that will store serialized object.

Create a stream from the file object.

Create an instance of BinaryFormatter.

Call serialize method of the instance passing it stream and object to serialize.

The steps for de-serializing the object are similar. The only change is that you need to call deserialize method of BinaryFormatter object.

Now, let us see an example where we have used 'real' class with public and shared members and properties to encapsulate them. The class also uses another supporting class. This is just to make clear that if your class contains further classes, all the classes in the chain will be serialized.

Example 2

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public class SerialTest
{
public void SerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
c.Name="bipin";
c.Age=26;
ClassToSerialize.CompanyName="xyz";
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Create);
BinaryFormatter b=new BinaryFormatter();
b.Serialize(s,c);
s.Close();
}
public void DeSerializeNow()
{
ClassToSerialize c=new ClassToSerialize();
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Open);
BinaryFormatter b=new BinaryFormatter();
c=(ClassToSerialize)b.Deserialize(s);
Console.WriteLine("Name :" + c.Name);
Console.WriteLine("Age :" + c.Age);
Console.WriteLine("Company Name :" + ClassToSerialize.CompanyName);
Console.WriteLine("Company Name :" + c.GetSupportClassString());
s.Close();
}
public static void Main(string[] s)
{
SerialTest st=new SerialTest();
st.SerializeNow();
st.DeSerializeNow();
}
}
public class ClassToSerialize
{
private int age;
private string name;
static string companyname;
SupportClass supp=new SupportClass();
public ClassToSerialize()
{
supp.SupportClassString="In support class";
}
public int Age
{
get
{
return age;
}
set
{
age=value;
}
}
public string Name
{
get
{
return name;
}
set
{
name=value;
}
}
public static string CompanyName
{
get
{
return companyname;
}
set
{
companyname=value;
}
}
public string GetSupportClassString()
{
return supp.SupportClassString;
}
}
public class SupportClass
{
public string SupportClassString;
}

Example 3

The final example shows how to serialize array of objects.

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
public class SerialTest
{
public void SerializeNow()
{
ClassToSerialize[] c=new ClassToSerialize[3];
c[0]=new ClassToSerialize();
c[0].Name="bipin";
c[0].Age=26;
c[1]=new ClassToSerialize();
c[1].Name="abc";
c[1].Age=75;
c[2]=new ClassToSerialize();
c[2].Name="pqr";
c[2].Age=50;
ClassToSerialize.CompanyName="xyz";
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Create);
BinaryFormatter b=new BinaryFormatter();
b.Serialize(s,c);
s.Close();
}
public void DeSerializeNow()
{
ClassToSerialize[] c;
File f=new File("temp.dat");
Stream s=f.Open(FileMode.Open);
BinaryFormatter b=new BinaryFormatter();
c=(ClassToSerialize[])b.Deserialize(s);
Console.WriteLine("Name :" + c[2].Name);
Console.WriteLine("Age :" + c[2].Age);
Console.WriteLine("Company Name :" + ClassToSerialize.CompanyName);
s.Close();
}
public static void Main(string[] s)
{
SerialTest st=new SerialTest();
st.SerializeNow();
st.DeSerializeNow();
}
}
public class ClassToSerialize
{
private int age;
private string name;
static string companyname;
public int Age
{
get
{
return age;
}
set
{
age=value;
}
}
public string Name
{
get
{
return name;
}
set
{
name=value;
}
}
public static string CompanyName
{
get
{
return companyname;
}
set
{
companyname=value;
}
}
}

Posted at

☆

Posted at

☆

By Majid Shahabfar
Introduction
The main goal of writing this article is to explain how we can mix the .NET library with the MFC library in very easy steps, gaining the benefits of .NET in unmanaged code such as MFC projects. So for this reason I’ve added ADO.NET in a MFC project to use the simple, type-safe and powerful functionalities of that library.

ADO.NET

In designing tools and technologies to meet the needs of today's developer, Microsoft recognized that an entirely new programming model for data access was needed, one that is built upon the .NET Framework. Building on the .NET Framework ensures that the data access technology would be uniform, components would share a common type system, design patterns and naming conventions. ADO.NET was designed to meet the needs of this new programming model: disconnected data architecture, tight integration with XML, common data representation with the ability to combine data from multiple and varied data sources, and optimized facilities for interacting with a database, all native to the .NET Framework.
Mixing Managed and Unmanaged code

To use managed code in a MFC projects we must change some MFC project settings and add some code to declare the .NET library.

Changing Configuration

To alter the configuration of your MFC project to use unmanaged code, change the following items in the Configuration Properties dialog box.

General - Use Managed Extensions = YES

C/C++ - General - Debug Information Format = Program Database (/Zi)

C/C++ - General - Compile As Managed = Assembly Support (/clr)

C/C++ - Code Generation - Enable Minimal Rebuild = No

C/C++ - Code Generation - Basic Runtime Checks = Default

The /clr compiler option provides module-level control for compiling functions either as managed or unmanaged. Now you must add the following code wherever you want to use managed code. If you want use managed code in several classes of your project it is better that you add this code to the stdafx.h file.

#pragma managed

#using
#using
#using

#using namespace System;
#using namespace System::Data;
#using namespace System::Data::OleDb;

The managed pragma enables function-level control for compiling functions as managed. An unmanaged function will be compiled for the native platform, and execution of that portion of the program will be passed to the native platform by the common language runtime.

Because we are using ADO.NET in our project so we have to add System::Data and since we want to use the MS Access database we have added System::Data::OleDb.
__gc Pointers in Unmanaged Classes

To declare a managed pointer as member in a class we must use __gc pointers. It is illegal to declare a member of an unmanaged class to have __gc pointer type. In order to point to a managed object from the C++ heap, the header file vcclr.h provides the type-safe wrapper template gcroot. Use of this template allows the programmer to embed a virtual __gc pointer in an unmanaged class and treat it as if it were the underlying type. The header file vcclr.h is included in VS.NET by default and you don’t need to include it to your application. Anyway this file can be found in the \Microsoft Visual Studio .NET\Vc7\include directory.

Therefore for declaring pointers of OleDB classes as members we must writing something like this.

gcroot m_OleDbConnection;
gcroot m_OleDb;
gcroot m_Reader;

Writing Managed Code

Now it is time to write managed code in an unmanaged function.
Collapse

#pragma push_macro("new")
#undef new

try
{
m_OleDbConnection = new OleDbConnection(
S"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\test.mdb"
);
m_OleDbConnection->Open(); // Open up the connection

m_OleDb = new OleDbCommand(S"select * from Persons", m_OleDbConnection);
m_Reader = m_OleDb->ExecuteReader();

int count = 0;

while (m_Reader->Read())
{
AddToList(count,m_Reader->get_Item("First Name")->ToString(),
m_Reader->get_Item("Last Name")->ToString(),
m_Reader->get_Item("Phone Number")->ToString()
);
count++;
}
}
catch(Exception *e)
{
AfxMessageBox(CString(e->ToString()));
}
__finally
{
m_Reader->Close();
m_OleDbConnection->Close();
}

#pragma pop_macro("new")

the #pragma push_macro("new"), #undef new and #pragma pop_macro("new") are used when your project is in debug mode. Otherwise you will get errors saying placement arguments not allowed while creating instances of managed classes.

This was a small sample that indicates how we can use .NET library in MFC based projects. By following this sample You can write more complicated projects and using more benefits of .NET. It is easy to cope with and entirely feasible to extend your own MFC applications with managed code.
About the Author

Posted at

☆

Posted at

☆

Posted at

☆

Posted at

☆

Posted at

☆

Custom DataGrid Paging at the Server
by Peter A. Bromberg, Ph.D.

Peter Bromberg

"We are all acting like there isn't an elephant in the room."
- Sen. Joe Biden, at opening of Samuel Alito Confirmation Hearings

The ASP.NET DataGrid's built-in Paging capabilty is a great feature, and it's relatively easy to learn to use. However, as most developers are aware, the downside is that this paging is done based on bringing back the entire resultset every time a new page is requested. Of course, you can cache the resultset to cut down on bandwidth.

But what if you have 50,000 or 100,000 rows that you need to offer your user to page through? That's a lot of baggage to bring along! Certainly you do not want to load and / or cache all this data when, for example, your user is really only looking at ten rows at a time on a paged DataGrid. What you really want to do is show them the total number of pages in a standard DataGrid Pager Bar arrangement, and send them only the ten rows representing the actual page that they have selected to see.
The answer to this question is to use Custom Paging. The DataGrid has two features that you need to use for this:

1) Set the AllowCustomPaging property to "true".

2) Set the VirtualItemCount to the total number of available rows from each query so that the Pager knows what to display on the Pager Bar.

The final piece of the equation is to have a stored procedure that can dynamically select the correct rows and only send back "one page" worth of rows, whatever your PageSize happens to be.

Fortunately, the code to implement custom paging in an ASP.NET page is trivial. The stored procedures necessary for this arrangement are not. However, there is a broad range of solutions and my philosophy is "keep it simple". So I will present my own version of a dynamically created stored proc to handle this where you can pass in parameters consisting of the table's PrimaryKey, the table name, the Current Page index, the number of rows per Page, and finally, if desired, a custom "WHERE" clause of your choosing. The stored proc will take care of the rest.

My version is a pretty short sproc - a lot shorter and simpler than many you will find. However, you may find that you need more, and if you do, then at least this solution will give you the basis from which to understand what you need for your custom solution.

What I'll do here is show the stored proc, fashioned to get rows from the Northwind Orders table, which almost everyone has handy. However, it can be used or modified to work with most any table. If you need rows from more than one table, then you'll need to modify this to include the proper JOIN syntax.

Now, the sproc:

CREATE PROC dbo.GetPagedData

@pageSize int,
@tablename varchar(100) ,
@PrimaryKey varchar(50) ,
@CurrentPage int ,
@WhereClause varchar(250)

AS

if(@WhereClause IS NULL or @WhereClause='') Set @WhereClause=' 1=1 '
Declare @sql nvarchar(4000)
declare @numrecs int

Set @numrecs=@pageSize*@currentPage

set @sql='SELECT TOP ' + cast(@pageSize as varchar(5))+' * FROM ' +@tablename
Set @sql =@sql + ' WHERE '+cast(@PrimaryKey as varchar(50))+ ' NOT IN (SELECT TOP '
set @sql=@sql+ cast(@numrecs as varchar(5))
set @sql=@Sql+ ' ' +@primarykey +' FROM ' +@tableName + ' WHERE '+@whereClause +
' ORDER BY ' +cast(@primarykey as varchar(50)) +' ) '
set @Sql=@sql + ' AND '+ @whereClause
Set @Sql=@Sql + ' ORDER BY '+cast(@primarykey as varchar(50))
--print @sql

EXEC sp_executeSql @sql

Set @sql='Select count(*) FROM ' +@tablename + ' WHERE ' +@whereclause

EXEC sp_executeSql @sql

As can be easily seen, all this sproc does is construct dynamic SQL to return @pageSize number of rows using the TOP Keyword along with a limiting SubSelect which also uses the TOP keyword, and it applies your where clause, if any. Finally it does a second Select to get the total number of rows that match the query. I use sp_ExecuteSql as it is more efficient. You can even see the commented "print @sql" line I used to ensure my dynamic sql turned out OK. I really don't like dynamic Sql, but like any other evil thing, it has its uses. Pretty simple!

The only other thing we need to look at is the codebehind for the page, which is also surprisingly simple:

using System;

using System.Collections;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Web;

using System.Web.SessionState;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.HtmlControls;

using Microsoft.ApplicationBlocks.Data;

namespace PagedData

{

public class WebForm1 : System.Web.UI.Page

{

protected System.Web.UI.WebControls.DataGrid DataGrid1;

protected int curPageSize =0;

private void Page_Load(object sender, System.EventArgs e)

{

curPageSize=this.DataGrid1.PageSize;

// if we just loaded the page for the first time, display page 1 of our data:

if(!IsPostBack)

BindGrid(curPageSize,1);

}

#region Web Form Designer generated code

override protected void OnInit(EventArgs e)

{

InitializeComponent();

base.OnInit(e);

}

private void InitializeComponent()

{

this.DataGrid1.PageIndexChanged+=new System.Web.UI.WebControls.DataGridPageChangedEventHandler(
this.DataGrid1_PageIndexChanged);

this.Load += new System.EventHandler(this.Page_Load);

}

#endregion

private void BindGrid(int pageSize, int pageNumber)

{

string cnString= System.Configuration.ConfigurationSettings.AppSettings["connectionString"];

/* sproc parameters: @pageSize int,

@tablename varchar(100),

@PrimaryKey varchar(50),

@CurrentPage int,

@WhereClause varchar(250) */

string tableName = "orders";

string primaryKey="orderid";

string whereClause="orderDate >='8/1/1997'";

// string whereClause=String.Empty ; // null string for no "where" clause

object[] parms = new object[] {pageSize,tableName,primaryKey, pageNumber, whereClause};

DataSet ds= SqlHelper.ExecuteDataset(cnString,"dbo.GetPagedData",parms);

// Our second datatable has 1 row, 1 column - the number of total rows available to page

// with custom paging, that gets assigned to the VirtualItemCount property:

this.DataGrid1.VirtualItemCount =Convert.ToInt32(ds.Tables[1].Rows[0][0]);

this.DataGrid1.DataSource=ds.Tables[0];

DataGrid1.CurrentPageIndex =pageNumber;

DataGrid1.DataBind();

}

private void DataGrid1_PageIndexChanged(object source, System.Web.UI.WebControls.DataGridPageChangedEventArgs e)

{

// user clicks forward or back, just call BindGrid with the NewPageIndex:

BindGrid(this.curPageSize , e.NewPageIndex);

}

}

}
How it works:

The main part of the working code is the BindGrid method, which accepts a PageSize and the expected pageNumber (or PageIndex, in DataGridSpeak). It puts together the parameter list for the Stored Proc of PageSize, TableName, PrimaryKey (the column name), CurrentPage, and any Where Clause, then calls the SqlHelper ExecuteDataSet method to get the DataSet, which contains two tables: the first is our "Page" of data, and the second is a single row and column containing the count of total records that can be retrieved for this particular query. This is needed to store in the grid's VirtualItemCount, which it uses to construct the correct Pager Bar elements.

And of course, I use the MS Data Access Application Block "SqlHelper Class" for my data access. Two lines of code to make a stored proc call with parameters, and your SqlParameters get cached automatically for a performance boost to boot! Hey, if you can write better "Best Practices" data access code than this, knock yourself out - I can't!

Whenever a user clicks on a numbered page in the PagerBar, the PageIndexChanged event is fired, and it simply calls BindGrid again, supplying the curPageSize of the grid on the page, and the NewPageIndex. That's all there is to it! You can find a lot of solutions for server-side DataGrid paging. Most of them will be nowhere near as simple and easy to understand as this one!

You will note that I have left out exception handling. The sole purpose of this omission is to keep the code as simple and easy - to - understand as possible for the purpose of a tutorial. In "real life" you should always have good quality exception checking that looks for specific exception types (e.g. "SqlException") whereever in your code anything could possibly go wrong. And, you don't just catch an exception -- you make a business decision -- should I allow the app to continue, show a message to the user, or do I need to terminate the app?

Hope this is helpful to you in your travails.
Download the VS.NET 2003 Solution that accompanies this article

havdone's memory

☆

☆

☆

☆

☆

☆

☆

☆

☆

☆

About Me

Catergories

URL LINKS

Blog Archive