Share your minds, soul, and idea

Archive for the ‘C#’ Category

First of all I will give a brief overview of Postback and Callback. When ever you register a control’s server side event, ASP.Net register a JavaScript which will submit the form’s details and on the server it fires the event which is registered for the control.

ASP.net register __doPostBack javascript function. Syntax for the script is __doPostBack(‘Event Target’,'Event Argument’); Here Event Target can be a control or it can be a function created by developer. You can also generate a postback script reference for a control by using GetPostBackScript function. Now ASP.Net page always handle the PostBack event by it self.

For Callback you have to impliment a ICallBackEventHandler interface. After implimenting ICallBackEventHandler a page must contain two events, RaiseCallBackEvent with return type void and GetCallBackResult with return type string. Your code logic will be contained in the RaiseCallBackEvent function code block and the result of the Callback will be contained returned by GetCallBackResult. Function GetCallBackResult will call the client side callback result function. I will explain CallBack in detail in my future post.

Many of ASP.Net users are facing a problem with invalid Postback or Callback argument error. Invalid PostBack or CallBack argument error is basically raise because of Event Validation feature. The EventValidation feature is a new feature in ASP.NET 2.0, and provides an additional level of checks to verify that a postback from a control on the client is really from that control and not from someone malicious using something like a cross-site script injection to try and manipulate things. It is part of our overall strategy of increasingly adding security in depth levels to the programming model — so that developers can be secure by default even if they forget to add security checks of their own.

Now, Invalid PostBack or CallBack argument error may occur when you are firing click event and the object is rebinding or its properties are changed in Page_Load event or someone is trying to hack into your system with cross site scripting. Each time .Net Framework render a page then it associate a unique Guid for all the controls. When binding a gridview or repeater, on each databind framework will associate a new guid for the contorl. So every time when you are firing event make sure Page_Load event does not change the control, because if the control changed the it will have a different Guid which have acutally fired the event for postback. Here are some scenario with this error.

1) Invalid Postback or Callback argument in GridView Problem may be: You are binding data in Page_Load event with either Object Data Source or Manual Binding with function call. This will make your GridView bind data on every event fire of any control. When you are firing any GridView command with OnRowCommand, before RowCommand fire your GridView will rebind and all control within it will be assigned to new id. So RowCommand could not get the item which have fired the event.  for Invalid Postback or Callback argument in GridView: You can bind your data within this if condition

if (!IsPostBack)
{
     //Your code for Bind data
}

This code will definitely give you solution if this not work then check whether any other control is not giving error.

2) Invalid Postback or Callback argument while submitting form. Problem may be: You have many textboxes and textareas and when user is entering “<” or “>” char then it is giving error. This is because of .Net framework is giving facility to validate request. This function will allow user not to submit script or html code directly so it is blocked. Solution for Invalid Postback or Callback argument while submitting form: You can replace this char with javascript before submitting the form replace “<” with “<” and “>” with “>” the javascript code is here

function ReplaceChar(obj)
{
     //Here obj is your textbox object
     var Textvalue = obj.value;
     Textvalue = Textvalue.replace("<","<");
     Textvalue = Textvalue.replace(">",">");
     obj.value = Textvalue;
}

The other solution for both of this issue is to set enableEventValidation=false You can set this option declaration <@ Page > or even you can put this code in your web. config file in block
//set it true if you want to validate your each request. If you do not validate the request then your security of data will be decrease so this is not the perfect solution If both of this solution not work then you can contact me on my email and if you find any new solution please post it comment.

Recently I had to work on customizing an ASP.NET Calendar control by adding text to the day cells for my team’s Logon Message project. This proved to be not as straight-forward as I thought so here is what I did in case someone else might want to do the same.

The best place to modify the text in a cell seems to be the DayRender event handler. So the first thing I tried was to just modify the e.Cell.Text property like this:

void Calendar1_DayRender(object sender, DayRenderEventArgs e)
{
     e.Cell.Text += “My text”;
}

The main problem was that after adding text to a day cell in the control I wasn’t able to select that day by clicking on the day number. Here is what you can do if you still want the select day functionality:

void Calendar1_DayRender(object sender, DayRenderEventArgs e)
{
     AddTextToDayCell(e, Datetime.Today, “MyText“);
}

void AddTextToDayCell(DayRenderEventArgs e, Datetime d, string text)
{
     if(e.Day.Date == d.Date)
     {
          string ID = ((System.TimeSpan)(e.Day.Date - new DateTime(2000, 1, 1))).Days.ToString();

          e.Cell.Text = "<a href=\"javascript:__doPostBack('Calendar1','" + ID + "')\" style=\"color:#663399\">" + e.Day.DayNumberText; //assuming the name of the calendar control is Calendar1.

          e.Cell.Text +=text;
     }
}

If you want your new text to act as a link to some other URL, you could modify the AddTextToCell function as follows:

private void Calendar1_DayRender(object sender, System.Web.UI.WebControls.DayRenderEventArgs e)
{
     AddTextToDayCell(e, DateTime.Today, "MyText", "<a href="http://fathir.com/">http://fathir.com</a>"); //this will add the MyText link to <a href="http://fathir.com/">http://fathir.com</a> to the current day's cell
}

void AddTextToDayCell(DayRenderEventArgs e, DateTime d, string text, string URL)
{
     if(e.Day.Date == d.Date)
     {
          string ID = ((System.TimeSpan)(e.Day.Date - new DateTime(2000, 1, 1))).Days.ToString();
          e.Cell.Text = "<a href=\"javascript:__doPostBack('Calendar1','" + ID + "')\" style=\"color:#663399\">" + e.Day.DayNumberText;
          e.Cell.Text += "<br /> <a href=\""+ URL + "\">" + text;
     }
}

Hope you’ll find this helpful.

In this tutorial, I’m going to go through the code required to edit the Windows registry using C#. This will include creating new keys and values as well as modifying existing ones.

The registry is a great way to save information between application launches. Many applications use the registry to save information about dialog sizes and placements. That way the user doesn’t have to resize and move dialogs every time the program starts.

Let’s start by creating a new registry key. The first thing we need to decide is where to put our new key. If you bring up the Registry Editor – type “regedit” in the run bar, you’ll notice the registry looks a lot like a file explorer. “Computer” is the root node with several child folders branching from it.

Most software packages will have a registry key inside

HKEY_LOCAL_MACHINE->SOFTWARE

These keys are available no matter who is logged in and is a good place to stick general application values. Let’s put a key in this folder called “My Registry Key”.

Registry is a class located in the Microsoft.Win32 namespace. Registry.LocalMachine means where going to be modifying the HKEY_LOCAL_MACHINE registry key. We passed in “SOFTWARE\\My Registry Key” to CreateSubKey because we wanted our new key created inside the “SOFTWARE” key. CreateSubKey has the option to take more arguments – mostly dealing with access and security, but they’re not important for this tutorial.

If you open the Registry Editor again, you’ll now see you’re new key. A key without any values is pretty useless, so let’s add a string value to it.

The OpenSubKey method is called to get a reference to our newly created key. It takes the path to the key, which is the same as when creating it, and it takes a boolean indicating whether or not we want to open it writable. Since we want to add a new value to this key, we want to set this to true.

Next, we simply call SetValue to create our new value. The SetValue function takes the name of the value as the first argument, the actual value as the second, and the type of value as the third. The RegistryValueKind enumeration has lots of different kinds of data, so most primitive types can be stored in the registry. If the value you’re trying to set doesn’t exist yet (like in this case), SetValue will create it for you.

Now let’s look at how to get values back out of the registry. It’s very similar to setting values and equally as easy.

We get a reference to our key exactly like we did before except this time we pass false for the writable argument. A call to GetValue is then made to retrieve the value from the registry. This function returns an object, so it must first be cast to your desired type – in this case string. It’s always wise to check that the return value is not null before casting it since it is possible that the registry value you’re trying to read doesn’t exist.

One very convenient features in windows is the Taskbar. To make it even better, those little icons can make something so “out of the way” that you can forget what is even down there. But, sometimes you want your applications to hang down there, out of the way, doing something that requires little attention. You can even make some notification bubbles show up if you want.

Today I am going to be using Visual Studio Express 2008, and luckily this makes things really easy. I am assuming that you know how to create a new project, so once you have one open, we can get started. I named my “HideTaskBar”, but as always, any name is fine.

This whole process revolves around an object named NotifyIcon. Like most .NET objects, this one is designed to make the job easier. With it we can give our application its very own cute icon in the taskbar, and notify our users of important information. Of course, to start you need to add the object to your form, so go ahead and do that. The object is a common control.

The NotifyIcon’s Properties

The first thing you absolutely must do is set the Icon property. This can be found in the properties window when you have the NotifyIcon object selected. If you don’t, nothing will show up in the taskbar tray.

Moving on to our code, the first thing we need to do is “hide” the form when we minimize it. To do this, we simply tie the action to the resize event. This is crude at best, but for this tutorial it gets the point across:

As I stated above, this simple code goes in the resize event of the form. We are checking to see if the form is minimized, if it is, we hide it. It’s that simple. Now we have to setup an “un-minimize” event that will show our app when we double click the icon. If you take a look at the NotifyIcon object, you will notice a DoubleClick event. How convenient, huh?

What we have to do on the event is show the form, then set its WindowState to normal:

Again, that simple. But, we can do a little more. How about adding a some notifications? Yeap, the NotifyIcon object can do that as well. Windows calls them bubbles, and you can access them through the object. Let’s go ahead and add one to notify us of the minimization of the app:

This will make a balloon tip pop up and notify us from the taskbar. As you can imagine the possibilities are pretty endless as far as the NotifyIcon object goes. You can use this pretty much anywhere, so any action can have a balloon tip. In fact, no one even said you have to use the notification icon for minimizing.

Now we know what is going on.

Code :

string strURL = "http://www.google.com";
string strTitle = "This is Pop Up Using C# (Server Side)";
string strParameter = "toolbar=No, width=300, height=190, resizable=No, top=400, left=600";

RegisterClientScriptBlock("Open Window",
"<script>window.open('" + strURL + "','" + strTitle + "','" + strParameter + "')</script>");

The following features are available in most browsers:

• toolbar=Yes/No
  Specifies whether to display the toolbar in the new window.
• location=Yes/No
  Specifies whether to display the address line in the new window.
• directories=Yes/No
  Specifies whether to display the Netscape directory buttons.
• status=Yes/No
  Specifies whether to display the browser status bar.
• menubar=Yes/No
  Specifies whether to display the browser menu bar.
• scrollbars=Yes/No
  Specifies whether the new window should have scrollbars.
• resizable=Yes/No
  Specifies whether the new window is resizable.
• width=pixels
  Specifies the width of the new window.
• height=pixels
  Specifies the height of the new window.
• top=pixels
  Specifies the Y coordinate of the top left corner of the new window. (Not supported in version 3 browsers.)
• left=pixels
  Specifies the X coordinate of the top left corner of the new window. (Not supported in version 3 browsers.)

Send e-mail without SMTP

public void sendSmtpDotnet()
{
System.Web.Mail.MailMessage m = new System.Web.Mail.MailMessage();
m.From = "someone@domain.com";
m.To = "to@domain.com";
m.Subject = "Test";
m.Body = "Body Test";

System.Web.Mail.SmtpMail.SmtpServer = "smtp.domain.com";
System.Web.Mail.SmtpMail.Send(m);
}

Send e-mail with SMTP

public void sendSmtpDotnet()
{
System.Web.Mail.MailMessage m = new System.Web.Mail.MailMessage();
m.From = "someone@domain.com";
m.To = "to@domain.com";
m.Subject = "Test";
m.Body = "Body Test";

m.Fields["http://schemas.microsoft.com/cdo/configuration/smtpauthenticate"] = 1;
//1 --> Authenticate=true
m.Fields["http://schemas.microsoft.com/cdo/configuration/smtpserverport"] = 2525;
m.Fields["http://schemas.microsoft.com/cdo/configuration/sendusing"] = 2;
//2 = Send the message using the network (SMTP over the network).

m.Fields["http://schemas.microsoft.com/cdo/configuration/sendusername"] = @"DOMAINNAME\USERNAME";
m.Fields["http://schemas.microsoft.com/cdo/configuration/sendpassword"] = "PASSWORD";

System.Web.Mail.SmtpMail.SmtpServer = "smtp.domain.org";
System.Web.Mail.SmtpMail.Send(m);
}

If you make unfounded assumptions about the type, length, format, or range of input, your application
is unlikely to be robust. Input validation can become a security issue if an attacker discovers that you
have made unfounded assumptions. The attacker can then supply carefully crafted input that
compromises your application by attempting SQL injection, cross-site scripting, and other injection
attacks. To avoid such vulnerability, you should validate text fields (such as names, addresses, tax
identification numbers, and so on) and use regular expressions to do the following:

• Constrain the acceptable range of input characters.
• Apply formatting rules. For example, pattern-based fields, such as tax identification numbers, ZIP Codes, or postal codes, require specific patterns of input characters.
• Check lengths.

Regular expression support is available to ASP.NET applications through the
RegularExpressionValidator control and the Regex class in the System.Text.RegularExpressions
namespace.

File Download : How To: Use Regular Expressions to Constrain Input in ASP.NET

Source : Microsoft patterns & practices Developer Center