Monthly Archives: February 2015

A few points to consider while working with literal string in ASP.NET

This post is for ASP.NET developers, working around with string literals in their applications for displaying run-time or dynamic data to their users. In the past few days, there have been quite a lot of new discussions about efficient way of creating a personalized string to represent the data on the websites.

A few tips that I had in my minds would be possible to share here with other developers of ASP.NET web applications. Note that, I have always been saying ASP.NET is built right on top of .NET framework, so anything that can be developed and run over .NET framework, can be used with ASP.NET too in the back-end. .NET exposes a few functions of the class System.String that are good for use with strings and modification and personalization of the strings.

Response messages

Usually, developers build a few messages to be shown to the clients as a result to their request. You can somehow, write a message (or return a message; possible way of usage in the ajax applications) in the Reponse.Write() function. You can write the string to return the data in the format of,

Response.Write("Thank you for your message " + name + " we will get back to you relating to your " + problem + " and we will have our " + client_name + " working on it right away to give you response in " + max_days);

Above code would work well, show the correct result, and at the very same time would be a good way to show your laziness too. No one uses string concatenation now-a-days. There is a very useful extension in .NET for String class. That is the .Format function. It is overloaded. Now let us consider writing the above code in a String.Format way,

     String.Format("Thank you for your message {0} we will get back to you relating to your {1} and we will have our {2} working on it right away to give you response in {3}"), name, problem, client_name, max_days);

The second way of doing the same is more efficient. You,

  1. Write the message to print in a very literal (constant) way, with just embedding the parameters in the form a {index}.
  2. You pass the parameters to add to the string as a second, third, fourth and so on number of parameter to the function.

Now once you’re about to write the message in a new way; such as updating the message. You won’t have to worry about the concatenation problems, parser errors; that get raised a lot in ASP.NET applications. You can simply write the message in a string form. Embed the parameters. Pass the values via variables and .NET would take care of the rest.

HTML attributes

Another common usage of building strings is to create the HTML markup of the web applications, on the run-time and then returning the response to the client to be rendered.

Such scenarios, require your to build the HTML markup, in a well formatted way and then sent down to client. For example, this question on CodeProject provides a similar scenario for us to investigate a possible solution to such problems. That is a problem, which gets raised due to a similar problem of string concatenation in HTML elements and attributes.

You should always write the HTML attributes in a very similar way, to avoid concatenation, and making a use of variables and the String.Format() function. An example code can be the following one (the code from the question).

Response.Write("<script language=javascript> 

The above code has a problem of attribute, well can be handled, but another major problem is the concatenation of the string by a variable. Which required him to add this value using a + operator but didn’t so caused a problem.

This could be possibly minimized by using the format function, in the following way,


Now the above string would be created as it is, but the parameter would be filled by the value passed. This now avoids any error of concatenation-type and so. Secondly, for HTML elements like image element, you can create that element in a way,

// Notice the single quote in the strings; whichw ould be converted to double.
String.Format("<img src='{0}' alt='{1}' />", image_source, alternate_text);
// which would yield
"<img src="~/value/of_image_source.png" alt="value of alternate_text" />"

These methods allow us to efficiently create strings. This code lets .NET framework handle the rest of the problems.

A tip for ajax developers in ASP.NET MVC framework

Download the sample project from Dropbox.

This is another quick blog post for the ASP.NET developers, who’re using ajax (or are going to use the ajax in their applications for async calls for the data to the server), and might be getting confused in the View-part of the MVC pattern. This blog post, would try to tip them up with a simple method of creating ajax functionality in their applications, and how to get the confusion about View-part clear. The background to this post is a question, that arose, of how to use the ajax to get the data in ASP.NET MVC framework. Although that was a simple task, but I know new developers get into trouble in making the logic, that is why I am writing this blog post, to explain the core-concept of the behaviour.

I will also be providing a sample code, that you can download and test in your application. This application would be a simple “Hello world, using Ajax in ASP.NET MVC” application. You can after that, make this application complex as per your own requirements.

Getting hands dirty in some ASP.NET code

First stage would be to write the back-end code for our application, which is the ASP.NET MVC application. Wait, the first thing I want to elaborate here is that ajax requests don’t usually require you to send entire HTML markup, to be rendered. Usually, ajax requests are used to download just a few details about the user, such as their name, their company name, or a little message such as success message for the process user has started. That is why, sending entire HTML markup would take a lot of time, and network size, by sending entire XML tree as HTML markup.

That is why, I am going to not-create any View in this project. But I am going to work with just a single Controller. That controller would be used to perform all of the actions, and after the controller has been made, I am going to use the Route mechanism to allow custom URLs in our application; which do not map to our actual HTML files on the application set up. Don’t worry, as the application would build up, the concept of this paragraph would start to get some gravity and you will understand it how did I do and what you would do in order to create your own Ajax running ASP.NET MVC application.

Note: If you’re unaware of the ASP.NET MVC framework itself, I force you to please go and read my other article that focuses on the ASP.NET MVC framework itself. In this blog post, I am not going to explain any concept about the framework itself, instead I am just going to simply swap things up and explain the ajax and ASP.NET MVC part. So, it would be better if you move on to that article and first understand the underlying concepts about Controller, View and Model (that makes up the MVC part of the ASP.NET MVC framework).

First of all, let us create a Controller. To create a controller, you can get some help from Visual Studio, click on the Controllers folder and Add Controller to it. Name it, what so ever you want to. I named it as AjaxController; to specify that it would control all of the ajax requests over HTTP protocol. Once that has been done, you can create your own action methods that would response to your own personal functions. I didn’t bother creating any complex task, instead I just simply created a function, named it as “CustomAction”. It would be used as the URL to our ajax handling web page.

Inside that page, you would write the following code, to handle it and provide the result to it. Like simple C# application, the functions can have any return data type and thus, in ASP.NET MVC application we can, instead of a View, return a string (or any other data type object) that would be sent down to the client as the response to his ajax request. It would be much simpler, and much shorter in structure.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace AjaxRequests_in_ASPNET_MVC.Controllers
   public class AjaxController : Controller
      // GET: Ajax
      public string Index()
         return "Not allowed";

      // Our custom action, URL would be /ajax/customaction
      public string CustomAction()
         // We're going to return a string, not a view.
         return "Hello world, using Ajax in ASP.NET MVC application.";

The above code would return a string, that can be then used as a response and rendered into the HTML or done what-so-ever with it.

Now let us change the routes to actually let the application run without having to use a web page that is a View inside the Ajax folder in our Views folder. Open the App_Start folder, and inside there open the RouteConfig file, and inside it. Write this new route.MapPath() function.

// Create a new route, set the controller to "Ajax" and the remaining would be the Action
// Note that there are no Views in the Views folder to map to this location.
   name: "AjaxController",
   url: "Ajax/{action}",
   defaults: new {controller = "Ajax"}

Now this code would create a routing scheme in your application, and is able to let your application run without actually having to have a specific file at that location to run and handle the ajax request. In the above code, I am using the URLs of the type “/ajax/customajax“, in this URL ajax is a constant string value, used as a path, and then the customajax would be the action of the controller. When this URL would be called, ASP.NET would execute the CustomAjax action of the controller, and would return the string result inside the function.

Performing the ajax code

The ajax code for this project is simple jQuery code to create an async request to the server, to download some more data. But before I share the code for the ajax request, I would like you to make a few changes in the _Layout.cshtml file of your project. The change is to include the jQuery library in the project, so that in the web page you can use the jQuery (because we will be using that layout). Add this line of code to your HTML markup’s <head> element.

<script src="~/Scripts/jquery-1.10.2.js"></script>

Now that the jQuery has been added to your HTML DOM, you can use this library in other pages which has this page set as their layouts, to make use of the jQuery syntax and other objects. I will be using the ajax.

The following code depicts the code used for an example ajax request,

$(document).ready(function () {
      // The URL
      url: "ajax/customaction",
      // If the request was successfull; which will be, if it is not successfull check for errors
      success: function (data) {
         // Alert the data; it would be "Hello world, using Ajax in ASP.NET MVC application."

Now once this code would run, it would try to make a call to the URL specified, in the above section we discussed how ASP.NET would handle that request using the routings and action methods, and then would return a single string value. It would finally alert the user with the string that would be returned. That would be a single ajax running application, which would return simple plain message to the user without any complex and large sized View.

Points of Interest

ASP.NET MVC framework can support the ajax requests, just like any simple website would.

You can use the routings to define your own custom URLs. You can define the paths that you want to use, and the controller or action patterns. You are not required to always have a view being returned to the user. Sometimes (if you want) you can also send any kind of data (which in turn would be serialized to string for transmitting).

Overview of DateTime object usage in ASP.NET websites and web applications

This blog post is meant for ASP.NET website and web application beginners who are striving their way through learning processes and want to build their own ASP.NET websites or web applications which makes use of real-time processes and/or some basic stuff like user profiles where they would be using some code to display the age of the user of whom profile is being viewed. I will be giving an overview of the DateTime object that would be used in ASP.NET website (so please make up your mind, that I am not actually talking about the DateTime object itself, instead I am going to talk about the procedures that will be taken in order to create a better user-interface for your website, so you can categorize this blog post as a front-end developer only post. If you’re interested in learning about the DateTime object, or wanted to learn about it and were redirected to this web page, then you’ll be wasting your time reading any further, please go to this article of mine that explains the DateTime object in .NET framework) and how you can use different methods and server-side codes (I will be using C#, you can chose your own) to use the objects to provide the data for your users and to build the user-interface that makes use of date instances, like age calculator, calender applications etc.

What might be the use of DateTime object?

Since ASP.NET developers are unaware of the actual processes taking place in the back end, because of awesome-ness of the ASP.NET framework, usually the new developers are left in dark of what actually these objects and functions are. The major thing and the major problem in this process is the usage of the keyword “var” in the ASP.NET web applications. Although it leaves a lot of not-required code behind (as in the second code line) but still it does’t allow new developers to understand the concept of “variable declaration“.

var dateTime = DateTime.Now;

// is same as

DateTime dateTime = DateTime.Now;

I had the same problem in the beginning. I didn’t know that each object must be saved in its own data type, and that is why I was unable to solve a problem where it said, “Unable to convert type right-value to left-value.” and that is why I thought it must be noted here, that no wonder ASP.NET is being used as a framework for web applications and there is a lot of abstraction in .NET framework and the ASP.NET, ASP.NET provides different assemblies as compared to those provided in the .NET framework and thus it usually feels like the code just runs.

In ASP.NET, DateTime object is used to represent different elements in HTML which require some data that would be better represented by the DateTime object, like a calender application, although you can write a loop for 31 days, but who wants to when you’ve got a structure to take care of that for you?

DateTime is a struct in .NET, it is not a class. See MSDN for more specification. There is a different between them both, one is value-type and other is reference-type; class is reference-type.

Similarly, you can perform different other tasks using DateTime object, such as finding the age and all other such processes. I will be explaining the concepts of finding the age, and the code required to complete the process in this blog post later. Until then, it is just a few scenarios that you might want to accomplish using DateTime object. Sometimes, your user wants to edit the way he gets to see the date on your application, the default machine date would be displayed as month/day/year, but people here from Pakistan are more familiar with day/month/year, you would have to either define multiple modules for that. Or, you can easily just use the DateTime object and display the dates in different formats that the user wants.

I would show how to pass simple string-like formats to the objects, to create their string notations. This would help you in different scenarios, such as fetching the user-friendly formats from database or other data source etc.

Using the DateTime in ASP.NET applications

Although ASP.NET applications are now using the .cshtml (or for VB.NET developers .vbhtml) pages which come embedded with all of the required assemblies already included into the file, for you to simply use them without having to reference them all one-by-one such as System and a bunch of other ASP.NET-required assemblies, but still you can make use of the .NET assemblies by using them as you would do them in any C# application. DateTime is found in the System namespace, so no further reference is required. You can use the DateTime object directly in the web page. Let us create our first module.

Calculating the age of the user

Of course for the user’s age, we’re going to use a DateTime object, to get the year and then the month and date of the user. I can’t say about the old days, but yes, you can possibly do that using three different integer values too; one for year, month and day. But since you have got the DateTime object you can easily just use this object and let the .NET framework handle the rest of the things for you.

A user’s age is the total days (in .NET framework I am talking, because there are no Years in .NET, just Day member) the member has lived on the planet, that started from the day he got born, or you can add some extra precision to the instance, by adding the hours, minutes and seconds for when the person was born. To calculate the age, you would subtract that date (birthdate) from the very now instance. In .NET framework, you can get the current instance of the time by using DateTime.Now, it is a static member, so you can get this value without having to create a new instance. Now let us write the code to calculate the age of the user. Suppose, I was a user, I would do it this way.

Did you know: A year is made up of 365.25 days, that is why there is a leap year after every 4 years.

/* -------------------------
 * Age finding code here... */

// Create a new object
var dateOfBirth = new DateTime(1995, 2, 2);
// Get the today object
var timeSpan = DateTime.Today.Subtract(dateOfBirth);
// Now let us stylize it a bit to make sure we get enough details.
// Divide the days by 365.25; make years
var age = (int) (timeSpan.TotalDays / 365.25);

This above code would find the age for the user (note the 356.25 in the division operator, if you would use the 365, then the age would be a little more than the real one). For me, it gave me 19; well that is my age at this instance of time, I might be elder when you are reading this blog post.

Age calculator. Provides the age of the user by using a DateTime object.
Age calculator. Provides the age of the user by using a DateTime object.

I donot need to show the HTML code, that was used, everyone knows this basic code to render the data in the HTML form.

Finding the total time spent

Usually, there are some scenarios in which developers want to find a time span which has passed for some other instance of time. Like, how much time has elapsed since last meeting, or how much time has passed since the last presentation etc. In such conditions, .NET framework has introduced an object TimeSpan, which is used to display the actual time span between two datetime objects. We all know the difference between two objects is found be subtracting the later one from the first one, the result in the case of DateTime objects is a TimeSpan object.

Let us take another example of this case, we will take a date (no longer than a day) to test the hours, and another date (no longer than a year) to test the days that have been passed since that particular date.

/* -------------------------------------------------
 * Code for time spans for finding the elapsed time */

// Create instances
var preTimeHour = new DateTime(2015, 2, 10);
var preTimeYear = new DateTime(2014, 8, 29);
// Get the time elapsed for these times
var elapsedHours = DateTime.Now.Subtract(preTimeHour).Hours;
var elapsedYear = DateTime.Now.Subtract(preTimeYear).Days;

The above code would find the values that we’ve appened (.Hours, and .Days). The following output was printed in this case (in my instance of time; yours would not resemble).

These dates and their results depend on my machine's time, the results on your screen would be different.

These dates and their results depend on my machine’s time, the results on your screen would be different.

Another similar scenario

There is another similar scenario, like we see on different social platforms that the time of the social activity is shown, in a format like “<variable> minutes ago”. That is the similar thing above discussed, but a slight difference. That is, that in this case now seconds would be involved, to set the precision for the actual time that the activity took place.

Tip: Do not use the Seconds member of the TimeSpan in this case, use the TotalSeconds. TotalSeconds would return the total number of the seconds for the time span, Seconds would only return the seconds part of the current TimeSpan notation (0-59 only). 

Let us take a few examples into consideration and see how .NET framework would let us know of how much time has been consumed since that time instance.

// Create a new generic list instance
var list = new List<DateTime>();
// Add a few instances to the list
list.Add(new DateTime(2014, 2, 2));
list.Add(new DateTime(2015, 1, 19));
list.Add(new DateTime(2015, 2, 12));
list.Add(new DateTime(2015, 2, 12, 1, 0, 0));
list.Add(new DateTime(2015, 2, 12, 0, 0, 0));

Now let us see, what did .NET render on the screen in the browser by using these instances. In the HTML markup, I wrote another code, to find the difference of the seconds. I am going to share that HTML markup (in Razor syntax) that you would be interested in reading in. Give the following markup a look,

@foreach (var dateTime in list)
   // For each of the instance of the DateTime, check how much time has elapsed
   var seconds = (DateTime.Now - dateTime).TotalSeconds;
      The time that has elapsed since @dateTime.ToString("MMMM dd, yyyy hh:mm:ss") is 
      @if (seconds < 1)
         // Zero seconds, hopefully that DateTime.Now object
         @:zero seconds, thus <i>just now</i>.
      else if (seconds > 0 && seconds < 60)
         // Seconds are greater than zero but less than 61 (minute)
         @:@seconds seconds.
      else if (seconds > 60 && seconds < 3600)
         // seconds are greater than minute but less than hour
         @:@(Convert.ToInt16(seconds / 60)) minutes.
      else if (seconds > 3600 && seconds < 86400)
         @:@(Convert.ToInt16(seconds / 3600)) hours.
         @:more than a day.

Now, that above code block would find the actual time that has elapsed. The only reason that it is a long one is that it had to perform some complex function, to find the actual instance, starting from a second, to minute, to hour and all the way to day. You can add more statements and conditions to test for a month, week or a year and so on. I am not going to create that entire solution plugin here, because it is just meant for a tutorial. The result of the above code was something like this,

Time Span representation of the date.

Time Span representation of the date.

Different formats of DateTime object

In our applications, we need to display the DateTime object in the format that user loves to view. Think of it like a user from America would be interested in reading the date in the format month/date/year, but a user from Pakistan would be loving to read the date in the format date/month/year. Now, .NET framework allows you to format your date into the format that you love it in. That is why, the .ToString() function of the DateTime object is overridden and overloaded to allow you to pass multiple values and parameters to change the format of the date in the format that the user wants.

Tip: Using the method I am going to show, you can use a string value from the database and pass it to the .ToString() function of the object and it would show it in that format.

I created a few string formats for date. That I would be using to display our date in, I am going to use a single instance of the DateTime, to remove any ambiguity from your minds and to show it in different formats by using those formats.

/* -----------------------------------
 * The DateTime ToString() extensions */
var formats = new List<string>();
formats.Add("MMMM dd, yyyy");
formats.Add("MMMM dd, yyyy hh:mm");
formats.Add("MMMM dd, yyyy 'at' hh:mm ss");
formats.Add("MMMM dd, yy hh:mm");
formats.Add("MMMM dd, yy dddd");

Now, the result of this string elements list would be printed, they would be used as format for the DateTime object, for the string notation of it. I used the following HTML, to convert the date into the representative string format.

@foreach (var format in formats)
    @:"@format" is used to render the DateTime object as, <b>@DateTime.Now.ToString(format)</b>.
    <br />

The result of this (at my instance of time was)

DateTime object different formats.

DateTime object different formats.

This is the blog post, of mine to explain the concept of the DateTime object in ASP.NET website.

Points of Interest

The DateTime object is available in the .NET framework, and can be used in the ASP.NET website. If you use .cshtml then you can make a good use of these assemblies without having to reference them in your file, they’re already there for you.

You can use the DateTime object, in performing different functions in the ASP.NET websites, that require to use a date-like data, such as calender applications. DateTime is an effective way of completing your project, instead of using integer data values for month, date and year etc.

You can pass simple string-data formats for the DateTime notation to convert the DateTime object into your own custom string notation. For more on this, you can read this MSDN document.

Sending emails over .NET framework, and general problems – using C# code

Most of the times new developers stumble upon a very simple task, “sending emails” over .NET framework. Well, I am not going to talk about any language here (C# or VB.NET, Visual C++ you’re also included), I am going to talk generally about the .NET framework and the assemblies exposed by .NET framework for sending the emails, using your own SMTP server’s settings, such as username/password combination, port number and (most specially) the hostname for your SMTP server.


Emails stands for electronic mail, and they are widely used in regular basis for communication, you can send email for sharing text data or you can send your albums over emails easily. Email has been a part of the internet entertainment since a great time, and people use many different email clients, some love the online clients eg. Gmail, Yahoo! etc, and some prefer an offline version of their email clients which use the internet connection to download the emails from a server, such as Thunderbird, Outlook etc.

But the fact is that all of them use the same protocol for transferring the emails over internet network. In this blog post, I will talk about sending the emails over the network, downloading the emails is a totally seperate topic and would have a seperate protocol working on the back end to download the emails from the server.

Sending the emails

Emails are sent using the SMTP protocol, over the internet. It is similar to the Hypertext protocol (not in way of communication, but in a way that is a protocol for communcation). For more on SMTP you can find yourself glad to read the Wikipedia page, I am not going in depth of the protocol here, instead I will just elaborate the methods to send the emails over the .NET framework.

What does .NET framework offer me?

.NET framework (who is oblivious to this one?) has a bunch of cool assemblies for us to work with, using our favourite languages, from C# to C++ and the assemblies in the .NET framework allow us to focus on the quality of the application and the logic, leaving the rest of the low-level coding to the framework itself, including and most specially the garbage collection like stuff and memory management.

.NET framework has a namespace, known as System.Net. This namespace is responsible for the network communication for the .NET applications. But we will be more concerned about the System.Net.Mail namespace, for working with the mail protocol, which exposes the SmtpClient, MailMessage classes for us to easily just pass our data to the objects and send the email using .NET framework.

Creating the module for sending email

Since .NET framework exposes a lot of frameworks to create your applications over, starting from as basic as Console application, to as much user-friendly as Windows Presentation Foundation. Interesting thing is, that in .NET framework same code can be used on the back-end of a Console app and the WPF application. So, the code that would be used to send the email in a Console application is just the same as you would be using for the WPF application. That is why I am not going to specify any framework, instead I am going to use a Console application for our project, for being simpler to be understood, and to focus more on the code instead. You can (in your own IDE) create any kind of application you want, from Windows Forms, to WPF to a web application (using ASP.NET).

Once your application has been created, you can create a simple module (function; not to be confused with the VB.NET’s Module). Inside that you can write the following code, don’t worry I will explain the code in the coming section of the blog post.

// You should use a using statement
using (SmtpClient client = new SmtpClient("<smtp-server-address>", 25))
   // Configure the client
   client.EnableSsl = true;
   client.Credentials = new NetworkCredential("<username>", "<password>");
   // client.UseDefaultCredentials = true;

   // A client has been created, now you need to create a MailMessage object
   MailMessage message = new MailMessage(
                            "", // From field
                            "", // Recipient field
                            "Hello", // Subject of the email message
                            "World!" // Email message body

   // Send the message

    * Since I was using Console app, that is why I am able to use the Console
    * object, your framework would have different ones. 
    * There is actually no need for these following lines, you can ignore them
    * if you want to. SMTP protocol would still send the email of yours. */
   // Print a notification message
   Console.WriteLine("Email has been sent.");
   // Just for the sake of pausing the application

Voila, (if you added correct details in the above code) you would have your emails sent to destination without any trouble; apart from Internet connection trouble. Now let us dissect the code into pieces and understand what happened, after that I will mention a few problems that arise in programming and cause a havoc for new developers in understanding the entire process, which includes the errors that are raised due to problems in connections and so on.

Explaination of the above code

First step in the code is the usage of the using statement. In .NET framework, you stumble upon different objects that use resources, which need to be disposed off properly, or atleast closed. For example, while a file is created it is required to call the Close() function, before any other process can use that file, similarly some processes requires that you can a Dispose() function on them, to release all the resources. But you can use a using statement, to let the .NET framework take care of all of the objects that need such functions to be called itself. For example, the following code,

using (SmtpClient client = new SmtpClient()) {
   // code here

is better than,

SmtpClient client = new SmtpClient();
// code here..

due to many particular factors, that I am not going to talk about here. That leaves the discussion about the using statement, you would find a few more deeper detail about using statements on MSDN documentations.

Next comes the SmtpClient object, the SmtpClient is used to create an object that would establish the connection between your machine and the SMTP server you’re using. SmtpClient requires you to set up a few things in it.

  1. Host name, which is the name of your SMTP server’s address in string format.
  2. Port that you will be using to connect, default is 25 (TCP port).
  3. Most of the connections require that you set the SSL active. You can see that happening in our code too.
  4. Credentials are required before you can use a service, most of the servers (Gmail, Outlook etc) require that you send a username/password combination in order to send email from your account using the SMTP protocol. That is why in most of the cases default credentials forward the developers into errors. We use NetworkCredential object (from System.Net namespace) to pass our username/password to the server.

Since SmtpClient is disposable, that is why we’re using it inside a using statement. We’re about to send an email, for that we create an object called MailMessage, and we pass our data to it. MailMessage object can set From, To, Subject and Body fields of an email message and then can be sent. You can see in our example, we’re using the constructor to create the MailMessage object that would hold the data for our From, To, Subject and Body fields.

Finally, we’re sending the email using the Send() function. Interesting thing is, in a GUI framework such as WPF or Win Forms, we should be using SendAsync for the sake of asynchrony in our application that would help us to create a fluid GUI for our application, otherwise the application woul stay stuck until the email has been sent and the control continues from this line of code. To learn more on asynchronous programming, please move to the MSDN link and learn more from there, they’ve got a great content for beginners like you.

A few errors in programming

Generally, there are always errors that developers miss and then tries to confuse himself for “Where did I miss it?”. Similarly, in sending the email and establishing a secure connection, there are usually a lot of problems, some are syntax, some are logically, but I would talk about the connection errors that might be raised. I tried to raise some exceptions myself to share them with you here, for you to understand when these exceptions might cause a problems for your environment.

Usually, the exceptions in the connection are raised only at the Send, or SendAsync method when the SmtpClient is not able to send your email successfully. It can be due to the connection problem, authentication problem or any other problem.

Problems with SMTP hostname

A general problem can be the hostname that you’re passing to the client to connect to, it must be correct and without the “http://“. You might stumble upon such a problem,

Hostname could not be resolved, because it is having "http://" in it. Just pass the, if you're using gmail as your SMTP server. Otherwise you should contact the SMTP developers for their SMTP hostname.

Hostname could not be resolved, because it is having “http://&#8221; in it. Just pass the, if you’re using gmail as your SMTP server. Otherwise you should contact the SMTP developers for their SMTP hostname.

This would be resolved, by making sure that the hostname is correct. Every SMTP provider has its own setting for its server. Make sure you’re using the correct ones. This is the first problem you would stumble upon if you’re going to get any error. Failure sending mail can also be raised if the Firewall is blocking the network. 

Another problem with the SmtpClient is, if you’re not using the correct port number, then the connection might not establish and the worst thing is that there won’t be any exception raised. For example, use 295 port number. The command would continue to execute without any success message or exception. Make sure you’re using correct port number, otherwise use the default TCP port number; 25. For me, 25 port number works always.

Errors authenticating the user

While servers require the correct authentication, it is compulsary that you pass correct and required authentication details to the server. First stage is to enable the SSL over your connection. Mostly, servers close the connection if the connection isn’t over SSL. Recall the code in this blog post, and see the enable SSL command,

client.EnableSsl = true;

After this, you should make sure that you’re using the correct combination of your username and password. If they’re incorrect, server is free to close the connection. The following exception is raised if any of such (authentication) problem occurs in your application.

Server requires SSL connection, or correct username/password combination. Make sure you're not wrong in both of these scenarios.

Server requires SSL connection, or correct username/password combination. Make sure you’re not wrong in both of these scenarios.

Once these problems are resolved, (and other problems don’t come out) your email would be sent, and you will see a success message in your application, mine showed me the following.

Email successfully sent! Success message in the Console application.

Email successfully sent! Success message in the Console application.

Points of Interest

In .NET framework you can use the System.Net and its namespace to work with network. For mailing, you use the System.Net.Mail namespace. System.Net.Mail exposes an SmtpClient object, that uses a hostname and a port to connect to the SMTP server for sending the emails. Some of the servers require SSL connection, and credentials (username/password combination).

MailMessage is the object you would use to send the email, you can fill this object with the From, To, Subject and Body field of your email message. SmtpClient would send this object, you can use Send or SendAsync methods to send email, depending on your framework and the methods that you would use to send the email from.

Exceptions are raised in SmtpClient, when the code reaches the Send (or SendAsync) function. That is because the connection problems occur at this stage, server tells the .NET framework for the errors in sending the email, and the exception is raised. Usually exceptions are raised due to following factors,

  1. Username/Password is incorrect.
  2. SSL is not enabled.
  3. Hostname is not correct, so the SmtpClient was not able to establish the connection at all.
  4. If the port number is incorrect, there is no error message at all. This is a tricky part for every developer. This can be minimized by using 25 (default TCP port).

SmtpClient exposes Dispose() function, that is why it is better to use the SmtpClient object in a using statement, not just as a simple (and ordinary) object to call dispose over later. Using a using statement lets you leave the releasing of the resources to the .NET framework itself.

For those, who are looking for a VB.NET code, you can use the Telerik converter to convert your C# code in VB.NET code (or vice versa).

.NET allows you to use the same code over different frameworks and platforms that run over .NET. Such as WPF, Console app, ASP.NET web applications. That is why, you can use this code above in almost all of your applications, no matter software apps, web apps or what-so-ever client application you’re creating until it runs over .NET framework. Because these assemblies are present in .NET, not in the language itself.