C#

எக்சல் கோப்பைப் டாட்நெட்டில் பயன்படுத்தினால் தகவல் இழப்பு ஏற்படுகிறதா?

சு. க்ருபா ஷங்கர் — Thu, 03 Apr 2008 07:26:38 GMT

எக்சல் கோப்புகளை எக்சல் ஆப்ஜக்ட் பயன்படுத்தாமலேயே வெறும் OleDbConnectionனை மட்டும் வைத்துக்கொண்டே டாட்நெட் தொழில்நுட்பம் பயன்படுத்த முடியும், கீழ்க்கண்டவாறு:

OleDbConnection xlConn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=d:\filename.xls;Extended Properties='Excel 8.0;'");

இதிலுள்ள ஒவ்வொரு சீட்டையும் ஒரு டேபிலாகப் படிக்கலாம்.

பிறகு டேபிளில் உள்ள வரிசைகளைப் படிக்க "select * from [sheet1$]" என்று அடாப்டரிலோ அல்லது கமாண்ட் ஆப்ஜக்டிலோ வினவளைக் கொடுக்கவேண்டியதுதான். இதில் ஒரு சிறிய பிரச்சனை என்னவென்றால் டேட்டாடைப்பை OleDbConnection புரிந்துகொள்ளும் விதம்தான். உதாரணமாக, எண்கள் மட்டும் இருக்கவேண்டிய ஒரு காலத்தில் (column) ஒரு எழுத்துச்சரத் தகவல் இருந்தது என்றால் அந்த தகவலை எடுத்துக்கொள்ளாமல் வெறும் null என்று அந்த இடத்தில் எடுத்துக்கொள்ளும். இதைத் தவிர்க்க, தகவல்தொடர்ப்புச் சரத்தில், IMEX=1 என்று சேர்த்துத் தரவேண்டும், கீழ்க்கண்டவாறு:

OleDbConnection xlConn = new OleDbConnection(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=d:\filename.xls;Extended Properties='Excel 8.0;IMEX=1'");

எண்கள் அடிப்படையிலான columnகளின் கூட்டுத்தொகையை க்ரிட்வியூவில் காண்பிக்க...

சு. க்ருபா ஷங்கர் — Thu, 27 Mar 2008 07:11:44 GMT

க்ரிட்வ்யூ கன்ட்ரோலை ஒரு டேட்டா டேபிள்/டேட்டாசெட்டுடன் பைன்ட் பண்ணிய பிறகு, எண்கள் இருக்கும் columnகளின் (numeric datatype columns) அடியில் மட்டும் எண்களின் கூட்டுத்தொகையைக் காண்பிக்க வேன்டியிருக்கலாம். பைன்ட் பண்ணிய டேபிளைப் பற்றிய விவரங்கள் நமக்கு முன்னமேயே தெரிந்திருந்தால் datatable.Compute("sum(columname)") மெத்தடைப் பயன்படுத்தி சுலபமாக இதைச் செய்துவிடலாம். ஆனால் இதற்கு எவையெவையெல்லாம் எண்களின் அடிப்படையில் அமைந்த fields என்று நிரல் எழுதும்போதே தெரிந்திருக்கவேண்டும். அப்படி இயலாத நேரங்களில், எந்தெந்த fields எண் வகையைச் சார்ந்தது என்று இயங்குநேரத்தில் கண்டுபிடித்து பிறகு Compute மெத்தடைப் பயன்படுத்தி sumஐ காண்பிக்கவேண்டும்.

ஒரு க்ரிட்வ்யூவையும், டேட்டாடேபிளையும் ஆர்க்யுமென்டாகக் கொடுத்தால், தானாகவே இந்த வேலையைச் செய்யும் ஒரு சின்ன ஃபங்க்ஷன் இதோ:

private void GenerateFooterTotal(GridView gvResult, DataTable dtbl)

{

#region Total for number columns

//We cant compute the total by specifying the field name since we dont

//know what table will be displayed and what columns need to be included for the sum.

//So, just get the sum of all the decimal and int type columns

Hashtable hsh = new Hashtable(); //This will hold the columns and position of the columns that are of numeric type

//Loop through each column to find out the numeric column.

//If numeric column is found, then include it for computing the sum

for (int intColPosition = 0; intColPosition < dtbl.Columns.Count; intColPosition++)

{

if (dtbl.Columns[intColPosition].DataType == typeof(decimal) || dtbl.Columns[intColPosition].DataType == typeof(int))

{

hsh.Add(dtbl.Columns[intColPosition], intColPosition);

}

//Now loop through the hashtable holding the numeric type columns and compute the sum to display in the footer

foreach (object obj in hsh.Keys)

{

//display the result (computed on the right side as assignment) in the footer = the sum of the particular numeric column name

gvResult.FooterRow.Cells[Convert.ToInt32(hsh[obj].ToString())].Text = String.Format("{0:0.00}", dtbl.Compute("sum(" + ((DataColumn)obj).ColumnName + ")", "")).ToString();

gvResult.FooterRow.Cells[Convert.ToInt32(hsh[obj].ToString())].Attributes["align"] = "right";

}

#endregion

}

private void FormatGridNumbers(GridView gvResult, DataTable dtbl)

{

System.Double dblValue = 0;

foreach (GridViewRow grow in gvResult.Rows)

{

for (int intCellPosition = 0; intCellPosition < grow.Cells.Count; intCellPosition++)

{

if(double.TryParse(grow.Cells[intCellPosition].Text, out dblValue))

{

grow.Cells[intCellPosition].Text = String.Format("{0:0.00;(0);0}", dblValue);

}

நிறுவன அறிக்கைகளில் லாப/நஷ்டத்தொகை குறிக்கும் விதம்

சு. க்ருபா ஷங்கர் — Thu, 06 Mar 2008 19:03:26 GMT

நிறுவனங்களின் இருப்பு அறிக்கை, லாப நஷ்டக்கணக்கு அறிக்கை போன்றவற்றில் நஷ்டத்தொகை பெரும்பாலும் அடைப்புக்குறிக்குள் குறிப்பிடப்பட்டிருக்கும். ஒரு நிறுவனத்தின் வரவு/செலவு போன்ற விவரங்கள் தகவல் தளத்தில் சேமிக்கப்பட்டிருக்கும். C#ல் துணையுடன் இத்தகைய வரவுகளில் இருந்து கழிக்கப்பட்ட செலவுத்தொகையை லாபமாகவோ நஷ்டமாகவோ அறிக்கையாகக் காண்பிக்கலாம். வரவை விட செலவு கம்மியாக இருந்தால் லாபம். செலவு வரவை விட அதிகம் இருந்தால் நஷ்டம். இந்த நிலையில்,

வரவு-செலவு = தொகை

இந்த தொகை negative எண்ணாக இருந்தால் நஷ்டம். இந்த தொகையை, - குறி நீக்கி அடைப்புக்குறிக்குள் காண்பிக்கவேண்டும்.

100 - 140 = -40 என்பதை, -40 என்று காண்பிக்காமல், (40) என்று அறிக்கையில் காண்பிக்கவேண்டும். ஒன்றிரண்டு லாப/நஷ்டத்தை மட்டுமே காண்பிக்க வேண்டும் என்றால், if/else போட்டு பாசிடிவ்/நெகடிவ் எண்களைப் பொருத்து அப்படியேவோ அல்லது ஒரு அடைப்புக்குறி போட்டோ காண்பித்து விடலாம். ஆனால் மிக அதிக அளவிலான இது போன்ற எண்களைக் காண்பிக்க வேண்டும் என்றால், String.Format என்ற ஃபங்க்ஷனைப் பயன்படுத்தலாம். இதற்கு ஒரு உதாரணம்:

String.Format("{0:0;(0);''}", தொகை)

மேற்குறிப்பிட்ட உதாரணமானது, மூன்று விதமான முடிவுகளை ஆராய்ந்து அதற்கேற்றவாறு ஒரு formatted stringஐத் தருகிறது. அதாவது, ஒரு எண் பாசிடிவ் எண்ணாக இருந்தால் அந்த எண்ணை எப்படியேவும், நெகடிவ் எண்ணாக இருந்தால் அதனை ஒரு அடைப்புக்குறிக்குள் - குறியை நீக்கிவிட்டும், வெறும் பூஜ்யமாக இருந்தால் ஒரு வெற்றுச்சரத்தையும் தருகிறது.

இந்த முறை வேறு சில சுற்றுவழி முறைகளைவிட வேகமானதாக இருக்கும்.

ஒன்றுக்குப் பலவற்றுடனான உறவுத் தகவல்களைப் புள்ளிவலையில் கையாளும் விதம்

சு. க்ருபா ஷங்கர் — Tue, 02 Oct 2007 19:22:38 GMT

one-to-many relationship என்பதை மொழி பெயர்த்ததால் இப்படி ஒரு சொதப்பலான தலைப்பு அமைந்து விட்டதென்றாலும், இவ்வகையில் அமைந்த தகவல்தளம் மிகவும் பயனுள்ளது என்பதில் ஒரு துளியும் சந்தேகம் இல்லை.

வேறு டேபிலில் உள்ள பல வரிசைகளுடன் தொடர்பில் இருக்கும் ஒரு தகவல் வரிசையை, டேட்டாக்ரிட் கண்ட்ரோலின் துணை கொண்டு காண்பிப்பது மிகவும் சுலபம். ஒரு எடுத்துக்காட்டிற்கு, subtext என்ற திறமூல மென்பொருள் கொண்டு இயங்கும் இந்த வலைப்பூவிற்கான தகவல் தள அமைப்பில் இருந்து இரண்டு டேபிள்களை எடுத்துக்கொள்வோம்.

Subtext_Config

BlogId

UserName

Subtext_Content

Title

Text

DateAdded

BlogId

சப்டெக்ட்ஸ்ட்டில் பல வலைப்பூக்களை வைத்துக்கொள்ளலாம், பல பயனர்க்கணக்குகளை உருவாக்கிக்கொள்ளலாம். ஒவ்வொரு வலைப்பூவுக்கும் ஒரு BlogIdயும் ஒரு பயனரும் உண்டு. இந்த விவரம் subtext_config டேபிளில் இருக்கும். வலைப்பூவின் பதிவுகளும் subtext_content டேபிளில் சேமிக்கப்படும். BlogId என்ற fieldன் துணைகொண்டு, எந்த வலைப்பூவிற்கு ஒரு குறிப்பிட்ட பதிவு சொந்தமானது என்பதை அறியலாம். இப்பொழுது நம் எடுத்துக்காட்டின் தொடர்ச்சியாக, ஒவ்வொரு வலைப்பூவிலும் உள்ள பதிவுகளின் தலைப்புக்களைக் காண்பிக்க ஒரு சிறிய formஐ c# மொழியில் உருவாக்குவோம்.

டேட்டா க்ரிட்டில் ஒரு டேட்டா டேபிளை bind செய்து தகவல் தளத்தில் உள்ள விவரங்களைப் பொதுவாகக் காண்பிப்போம். இரண்டு டேபிளில் உள்ள விவரங்கள் என்றால், inner join, outer join என்று ஏதாவது ஒன்றைப் பயன்படுத்தி, இணைத்துக் காண்பிக்கலாம். இது தவிரவும், DataRelations பயன்படுத்தியும் இரண்டு டேபிள்களை டாட்நெட்டில் இயக்க நேரத்தில் இணைத்துப் பயன்படுத்தலாம். கீழ்க்காணும் உதாரணத்தைப் பாருங்கள்:

1 SqlConnection con = new SqlConnection("server=myserver;uid=test;pwd=test;database=subtextdata");
2 SqlDataAdapter da = new SqlDataAdapter("select * from subtext_config;select * from subtext_content", con);
3 DataSet ds = new DataSet();
4 da.Fill(ds);
5 da.Dispose();
6 con.Dispose();
7 ds.Relations.Add("UserPosts", ds.Tables[0].Columns["BlogId"], ds.Tables[1].Columns["BlogId"]);
8 DataGrid1.DataSource = ds.Tables[0];
9 DataGrid1.DataBind();

இரண்டு வெவ்வேறு வினவலைப் பயன்படுத்தி, டேட்டா அடாப்டர் ஒன்று உருவாக்கி இரண்டு டேபிள்களில் உள்ள டேட்டாவையும் ஒரு டேட்டாசெட்டில் சேமிக்கிறோம். இதனால், ds என்ற டேட்டாசெட்டில், subtext_config என்ற டேபிளும், subtext_content என்ற டேபிளும் சேமிக்கப்பட்டுள்ளன. இவற்றை முறையே ds.Tables[0] என்றும் ds.Tables[1] என்றும் சுட்டலாம். பிறகு Relations.Add ஃபங்க்ஷனைப் பயன்படுத்தி, BlogId என்ற இரண்டு டேபிளுக்கும் பொதுவான fieldஐக் குறிப்பிட்டு UserPosts என்ற உறவினை உருவாக்குகிறோம். இனிமேல், முதல் வலைப்பூவின் பதிவுகளை எல்லாம் எடுக்க வேண்டும் என்றால், ds.Tables[0].Rows[0].GetChildRows("UserPosts") என்று குறிப்பிட்டால் போதும். Rows[0]விற்கான அத்தனை குழந்தை வரிசைகளும் ஒரு டேட்டா ரோ அர்ரேவாக வந்துவிடும். அதாவது முதல் வரிசையில் இருக்கும் முதல் வலைப்பூவுக்கான பதிவுகள் அனைத்தும் கிடைக்கும். இதுதான் டேட்டாசெட்டில் உள்ள இரண்டாவது டேபிளில் சேமிக்கப்பட்டு இருக்கிறது.

பிறகு DataGrid1 என்ற ஒரு டேட்டாக்ரிட்டுக்குரிய டேட்டா சோர்சுக்கு முதல் டேபிளான subtext_configஐ சுட்டுகிறோம், நிரல் வரி 8இல் இருக்கும் DataGrid1.DataSource = ds.Tables[0] என்று.

இப்பொழுது frontend html வரிகளைப் பார்ப்போம்:

<asp:DataGrid id="DataGrid1" runat="server" AutoGenerateColumns="False">
<Columns>
<asp:BoundColumn DataField="UserName" HeaderText="Blog User"></asp:BoundColumn>
<asp:TemplateColumn HeaderText="User Posts">
<ItemTemplate>
<ol>
<asp:Repeater id="Repeater1" runat="server" DataSource = '<%# ((System.Data.DataRowView)Container.DataItem).Row.GetChildRows("UserPosts") %>'>
<ItemTemplate>
<li /><%# DataBinder.Eval(Container.DataItem, "[Title]")%>
</ItemTemplate>
</asp:Repeater>
</ol>
</ItemTemplate>
</asp:TemplateColumn>
</Columns>
</asp:DataGrid>

இந்த டேட்டாக்ரிட்டில் இரண்டு காலம்கள் இருக்கின்றன, ஒன்று வலைப்பூவை நடத்துபவரின் பெயர்களைக் காண்பிக்க, இன்னொன்று ஒவ்வொரு வலைப்பூக்காரரின் பதிவுகளையும் காண்பிக்க.

இந்த இரண்டாவது காலத்தில்(column)தான் ஒரு ரிப்பீட்டர் கண்ட்ரோல் இருக்கிறது. ஒவ்வொரு தாய்வரிசைக்கான குழந்தைப் வரிசைகளையும் இதுதான் காண்பிக்கப்போகிறது. BlogIdதான் இந்த தாய்/குழந்தை உறவை நிர்ணயிக்கும் என்பதை ஏற்கனவே நாம் நிரலில் (8ஆம் வரி) குறிப்பிட்டு விட்டோம். எனவே, இப்பொழுது நாம் பண்ண வேண்டியது எல்லாம் ரிப்பீட்டரின் டேட்டா சோர்சுக்கு அந்தந்த வலைப்பூக்களின் குழந்தை வரிசைகளை அனுப்பி வைக்க வேண்டியது மட்டும்தான். ds.Tables[0].Rows[0].GetChildRows("UserPosts") என்பதை, இயக்க நேரத்தில் டேட்டாக்ரிட்டுக்குள் ((System.Data.DataRowView) Container.DataItem).Row.GetChildRows("UserPosts") என்று குறிப்பிடலாம். இதற்கு databinding command என்று பெயர். Four Guys From Rollaவில் இது பற்றி சற்று விரிவாக இருக்கிறது.

இப்படி ரிப்பீட்டர் கண்ட்ரோலுக்கு டேட்டா சோர்ஸ் செட் பண்ண மறந்து போய் விட்டால், itemtemplateஇல் குறிப்பிடப்பட்டிருக்கும் Title காலம் தாய்டேபிளான subtext_configகு உரியதாகக் கருதப்படும். வேறு ஏதாவது column ரிப்பீட்டர் கண்ட்ரோலின் itemtemplateஇல் இருந்து தாய் டேபிளில் இல்லாமல் போனால், Column Not Found பிழைச்செய்தி வரும். இதில் சுவையான விஷயம் என்னவென்றால், இவை அனைத்தையும் டேட்டாக்ரிட்டின் ItemDataBound ஈவண்ட்டிற்குப் போய் ரிப்பீட்டரைக் கண்டு பிடித்து, cast செய்து, டேட்டா செட்டை global variableஆக டிக்ளர் செய்து என்றெல்லாம் மாங்கு மாங்கு என்று நிரல் வரிகள் எழுதாமல் சுலபமாக ரிப்பீட்டர் கண்ட்ரோலின் டேட்டாசோர்சின் உதவியுடன் ஒரே வரியில் முடிக்க முடிந்ததுதான்.

web.configல் ஃபங்ஷன் பெயரைக் குறிப்பிடல்

சு. க்ருபா ஷங்கர் — Wed, 02 Aug 2006 09:12:48 GMT

உள்ளமைக்கோப்பில் (கான்ஃபிகரேஷன் ஃபைல்) இயங்குச்சூழலுக்குத் தகுந்தாற்போல் மாற்றி பயன்படுத்தவேண்டிய விவரங்களை பண்பு/மதிப்பு (கீ/வேல்யூ) அடிப்படையில் சேமித்து வைத்து, System.Configuration.ConfigurationSettings.AppSettings மூலமாக இயங்குநேரத்தில் பெற்றுக்கொள்ளலாம். இப்படி பெறப்படும் மதிப்பு ஒரு துணைநிரலின் பெயரென்றால் அந்த துணைநிரலை அழைக்க வேண்டிய தேவை எனக்கு வந்தது.

அதாவது,

< add key="FunctionName" value="myfunction1" />

என்று உள்ளமைக்கோப்பில் இருந்தால், ஒரு குறிப்பிட்ட classல் இருக்கும் myfunction1 என்ற துணைநிரலை அழைக்கவேண்டும்.

மென்பொருள் மேம்பாட்டுப் நிறுவல் ஒன்றில் தகவல்தள மாற்றங்கள் சில செய்யவேண்டியதால் இப்படிச் ஒரு முறையைக் கையாள வேண்டி வந்தது. நிறுவுநிரலிலேயே பயனரிடமிருந்து தகவல்தள விவரங்களை வாங்கி இப்படியான மாற்றங்களைச் செய்யலாம்தான். ஆனால் இந்த குறிப்பிட்ட மென்பொருள் பல தகவல் தளங்களைப் பயன்படுத்தும் சாத்தியமுடையது. ஒவ்வொரு சமயமும் ஒவ்வொரு தகவல் தளத்துடன் தொடர்பு ஏற்படுத்தி இயங்கும் நிரலாதலால், அத்தனை தகவல்தளங்களைப் பற்றிய விவரங்களும் ஒரே நேரத்தில் பயனரிடமிருந்து வாங்குவது சற்று சுற்றுவேலை.

இயங்குநேரத்தில் துணைநிரலின் பெயர் என்று யோசித்ததுமே நினைவுக்கு வருவது delegates. ஆனால் டெலிகேட்ஸ் பயன்படுத்துவதற்கு துணைநிரலின் பெயர் இயக்கநேரத்திற்கு முன்பே தெரியவேண்டும்.

எனவே, உள்ளமைக்கோப்பில் நிறுவும்போது இந்த ஃபங்க்ஷனின் பெயரைக் குறிப்பிட்டு விட்டு முதல் முறை இயங்கும் போது மட்டும் இந்த ஃபங்க்ஷன் அழைக்கப்படுமாறு பார்த்துக்கொள்ள வேண்டும். இரண்டாம் முறை இந்த மென்பொருள் இயங்கும்போது FunctionName என்ற பண்பு உள்ளமைக்கோப்பில் இல்லாமல் செய்துவிட வேண்டும்.

public ClassConstructor()
{
//இதர நிரல்வரிகள்
  if(System.Configuration.ConfigurationSettings.AppSettings["FunctionName"]!=null)
{
   Type tp = Type.GetType("Namespace.clsUpgrader");
System.Reflection.MethodInfo objMethodInfo = tp.GetMethod(System.Configuration.ConfigurationSettings.AppSettings["FunctionName"].ToString());
if(objMethodInfo == null)
{
   //MessageBox.Show("Invalid method name");
   }
   else
   {
   objMethodInfo.Invoke(new Namespace.clsUpgrader(), new object[]{});
   }
   System.Xml.XmlDocument xml = new System.Xml.XmlDocument(); //A reference to app.config/web.config.
   xml.Load(Application.ExecutablePath + ".config"); //the current application's configuration file is loaded. இணைய அடிப்படையிலான மென்பொருள் என்றால் Server.MapPath கொடுத்து web.config என்று கொடுத்துக்கொள்ளலாம்
   System.Xml.XmlNode xmlAppSettings = xml.SelectSingleNode("/configuration/appSettings");
   xmlAppSettings.RemoveChild(xml.SelectSingleNode("/configuration/appSettings/add[@key='FunctionName']")); //மேம்பாடு முடிந்து விட்டதால், இந்த பண்பை உள்ளமைக்கோப்பில் இருந்தே எடுத்து விடலாம்.
   xml.Save(Application.ExecutablePath + ".config"); //FunctionName keyஐ நீக்கியாகிவிட்டது. கோப்பை சேமித்து விடலாம்.
}
}

public class clsUpgrader
{
public clsUpgrader()
{

}
public static void myfunction1()
{
//மேம்பாட்டுக்கான நிரல்வரிகள்
}
}

துணைநிரற்கூறின் பெயரை இயக்க நேரத்தில் அறிந்து அழைப்பது, Factory Patternல் class பெயரை இயக்க நேரத்தில் முடிவுசெய்து ஆப்ஜக்ட் உருவாக்குவது போல் தோன்றிகிறது.