C#

Path is location of a file or a directory.This location can be on a disk , can be a network location or can refer to the location on some device.The location can be relative to some other location in which case it is called the relative path.If the location is not specific to any other location then it is called an absolute path.

For example if we have following directory structure
C:Current DirectoryFilesFile.txt

then if the current location is C:Current Directory ,the relative path to File.txt will be FilesFile.txt
and the absolute path will be C:Current DirectoryFilesFile.txt

To work with the paths in .NET System.IO.Path class is provided.Though we can work with paths without using this class ,Path makes it convenient and reduces chances of using an incorrect path.

Path is a static class in the System.IO namespace which contains some useful static methods and properties for working with the paths.It is important to understand that when we use these methods of the Path class the actual file or directory is not modified.We can retrieve or manipulate the string representation of the path but the actual path remains unchanged.

Also if we are passing some file or directory path to these methods we should verify if the directory or file actually exists.Since the path is not verified by these methods so we will not be informed if we pass some invalid or non-existent path to these methods.

Some of the useful methods related to working with Files in the Path class are:

Path.GetFileName(path)

This method returns the file name including the extension from path which is passed as an argument to this method
We can call this method as

string path= @" "C:Filesfile.txt";
Console.WriteLine("File Name={0}", Path.GetFileName(path));
//the above will display the output "file.txt"

Path.GetFileNameWithoutExtension(path)

This method returns the file name without the extension from the path which is passed as an argument to this method

string path= @" "C:Filesfile.txt"";
Console.WriteLine("File Name={0}", Path.GetFileNameWithoutExtension(path));
//returns "file"

Path.GetPathRoot(path)

Returns the root directory in the specified path.For example in the path “C:Filesfile.txt”  C: is the root directory.

string path = @"C:Filesfile.txt";
Console.WriteLine("path={0}", Path.GetPathRoot(path));
//it will display the string C:

Since we specified the absolute path in the C: drive we get the root directory as C:.If we specify the absolute path without specifying the directory name then we will get the root directory as “” which means the current directory.

If we call this method by passing the argument @”Filesfile.txt” then we will get the
root directory as “” which is current directory.

Path.GetTempPath()

Returns the path to the temporary folder on the users machine.This method doesn’t take any arguments.
Temp folder is located in the Users folder.So calling this method returns a path similar to:
C:UsersUserNameAppDataLocalTemp

Path.Combine(path1,path2)

Combines two fragments of a path to form a single combined path.Instead of concatenating the paths we can use this method.

Console.WriteLine(Path.Combine("C:", @"Filesfile.txt"));//C:Filesfile.txt
Console.WriteLine(Path.Combine(@"C:", @"Filesfile.txt"));//C:Filesfile.txt
Console.WriteLine(Path.Combine(@"C:Files", @"file.txt"));//file.txt

Path class in C# for working with file paths reduces chances of errors of forming an incorrect path ,since it checks if path separators are valid.
If we concatenate two strings representing paths and if the combined path is invalid then we are not informed about it.For example if join the two paths as:

string combinedPath = @"C:" + @"Filesfile.txt";

then the value of combinedPath will be C:\Filesfile.txt which is invalid path.

But if we join the above two paths using the Combine method then we will get the following valid path.
Filesfile.txt
The Combine method is smart enough not to concatenate the two “” separators together.

ashish shukla

ReadOnlyCollection is a collection of items that can not be changed. To understand the use of
ReadOnlyCollection first lets see the behaviour of ordinary collections in .NET

We declare a List<T> of strings in C# as

List<string> namesLst = new List<string>();

now if we want to prevent users from modifying this list we may try to use the readonly modifier.As readonly is used to prevent changing the value of a variable once it is declared so this modifier seems appropriate for our use.

So we may declare the List<string> as

static readonly List<string> namesLst = new List<string>();

Now if we try to add the items to the above collection as

namesLst.Add("Mark");
namesLst.Add("Mike");
namesLst.Add("John");
namesLst.Add("Jenny");

Even though we have declared the collection as readonly we are able to add the items to the collection using the above code.

So readonly modifier though appropriate for declaring readonly variables doesn’t makes the collection as readonly.To make the collection as immutable which can not be modified we need to wrap our collection in ReadOnlyCollection instance as:

ReadOnlyCollection<string> namesReadOnlyLst;
namesReadOnlyLst = new ReadOnlyCollection<string>(namesLst);

If we expose the ReadOnlyCollection then it becomes immutable and items can not be added to this collection.

If we have an array we can make it as readonly by using the AsReadOnly() method of the Array class.We use this method as:

Array.AsReadOnly(array)

For example if we have an array of names we can make it as immutable as:

ReadOnlyCollection<string> namesReadOnlyLst;
string[] names = new string[] { "Mark", "Mike", "John", "Mark", "Jenny" };
namesReadOnlyLst = Array.AsReadOnly(names);

Now there is no way an item can be added to the namesReadOnlyLst collection above.As ReadOnlyCollection doesn’t contains Add method or an indexer to add items to the collection so we can not add new items to a ReadOnlyCollection.

Example of ReadOnlyCollection

In the following SavingsAccount class we have a property Users which is of type ReadOnlyCollection<User>.Since it is ReadOnlyCollection so clients of the SavingsAccount class will not be able to add new users to the collection.

For adding a new user we have to use the AddUser(User user) method which is declared as private.Since we have declared the method as private hence we can add a new user from only within the SavingsAccount class.

class SavingsAccount
{
private List<User> _users = new List<User>();

public ReadOnlyCollection<User> Users
{
get
{
return _users.AsReadOnly();
}
}

private void AddUser(User user)
{
_users.Add(user);
}

}

So for adding new users to the collection can call the AddUser(User user) method from within the class.For example we can load the users from the database in the constructor.This ensures that the sensitive will not be tempered with by the consumers of the class.

So as ReadOnlyCollection in .NET   prevents a collection from being modified ,we can expose our collection as ReadOnlyCollection if we want to ensure that it can not be modified by the users of our class.

ashish shukla

One of the most common exceptions while developing a C# application is a null reference exception.I believe most of us have encountered this exception at some point of time.The reason for this exception is that we are trying to access a type member when that type reference is null or not assigned an object.

For example if we consider the following example

public static void Main(string[] args)
{
 Employee emp = new Employee();
 emp.Name = "Mike";
 Console.WriteLine("Employee Name{0} Employee City", emp.Name, emp.Details.City);

}

class Employee
{
    public string Name { get; set; }
    public DetailInfo Details { get; set; }
}

public class DetailInfo
    {
        public int PostCode { get; set; }
        public string City { get; set; }
        public string State { get; set; }
     }

In the above example Employee class contains a reference to DetailInfo class.If we execute the above code then we will get null reference exception.Since Details property is null so we get this exception.

In the prior versions of C# we can prevent the above exception by checking the null value in the if condition as

 if(emp.Details!=null)
        Console.WriteLine("Employee Name{0} Employee City", emp.Name, emp.Details.City);

Though the above null condition will check for the null value of the string parameter we can still get the null reference exception.If need to display the employee details in uppercase then we will get the null reference excetion

if (emp.Details!=null)
Console.WriteLine("Employee Name{0} Employee City", emp.Name.ToUpper(), emp.Details.City.ToUpper());

To prevent the exception we will have to put one more null check as

if (emp.Details != null)
{
if(emp.Details.City!=null)
Console.WriteLine("Employee Name{0} Employee City", emp.Name.ToUpper(), emp.Details.City.ToUpper());
else
Console.WriteLine("Employee Name{0} Employee City", emp.Name.ToUpper());
}

And if we want to display other Employee details then we will have to increase that many null checks.

So from the above example it is clear that null checks are commonly used to prevent exceptions because of null references.

Null-conditional Operator

C# 6 includes the null conditional operator.

It verifies if the object instance for null reference before  accessing the members of the object.If obj is an object of class A and Name is a property defined by class A then we can use this operator as:

obj?.Name

If obj is null then Name is not accessed and null reference exception is not thrown.

Above is a very simple use of this operator.It is more useful in the case of classes which contains references to other classes.

Using the null conditional operator in C# 6 we can rewrite the above code to display the Employee details as

Console.WriteLine("Employee Name{0} Employee City", emp?.Name.ToUpper(), emp?.Details?.City?.ToUpper());

So as we can see in the above example by using the Null Conditional Operator of C# 6.0 we have replaced multiple if conditions with this operator.It is more useful in the case of nested references as in the above example.

ashish shukla

Properties in C#

Properties have been an important part of C#.They have evolved quite a bit since the initial version.They are a means to provide controlled access to the state of the objects.For example we can declare the state of a class using the following fields

public class Employee
{
public int Age;
public string Name;
public bool isPermanent;
public string Address;
}

But the problem with the above code is that the user of the class can assign any acceptable values for string and int data types.So for example Age can be assigned the value 1500 ,though it is a unrealistic values.So to provide controlled access to the state of the class properties were included in C#.

Using properties we can declare the above Employee class as

public class Employee
{
private int age;
public int Age
{
get
{
return age;
}
set
{
if (age > 20 && age < 60)
{
age = value;
}
}
}

private string name;
public string Name
{
get
{
return name;
}
set
{
name = value;
}
}

private bool isPermanent;
public bool IsPermanent
{
get
{
return isPermanent;
}
set
{
isPermanent = value;
}
}

private string address ;
public string Address
{
get
{
return address ;
}
set
{
address = value;
}
}
}

Properties are used like variables but contain logic which is executed when value is fetched or assigned.This enables to verify the state of the class and keeps the implementation details hidden.

Auto Properties in C# 3.0

Though properties solved access problem but when creating properties we have to declare the backing field.In the above example IsPermanent and Address properties are just returning and setting the backing field.This is a redundant work which is required for every property declaration.In other words this is just a boiler-plate code which we had to write for the get and set accessors.
To avoid this declaration of the backing fields auto properties were introduced.

Using auto properties we can declare IsPermanent and Address properties as:

public bool isPermanent { get; set; } ;
public string Address { get; set; } ;

So auto properties provide  just a syntactic shortcut for declaring properties.

Auto Property Initializers in C# 6.0

Though auto properties simplifies declaration of properties but they have one limitation, they can not be initialized at the time of declaration.So the only way to initialized the auto properties is within constructors or any other method.

This can cause difficulty in understanding since the property is not initialized at the place of the declaration.
In C# 6 we can initialize the property at the place of the declaration.So the following is valid in C# 6.0:

public bool isPermanent { get; set; } = true;
public string Address { get; set; } = GetDefaultAddress();

Above is a simple example of auto property initializers ,but they could be really useful in more complex scenarios.

For example if  we consider a class having lots of properties.If we initialize such a property in the constructor then it can be difficult to understand the initialization logic for somebody looking at the code.

Below few auto properties are declared in a class

class Employee
{
public int Age { get; set; }
public string CompanyName { get; set; }
public string CompanyAddress { get; set; }
public string Department { get; set}
public decimal Bonus { get; set}

public Employee()
{
this.CompanyName = "Name";
this.CompanyAddress = "XYZ";
this.Department = "Default Department";
this.Bonus = Constants.DefaultBonus;

}
}

We need to initialize auto properties in the constructor in the prior versions of C#.

By using the auto property initializer in C# 6.0 we can initialize them as:

class Employee
{
public int Age { get; set; }
public string CompanyName { get; set; } = "Name";
public string CompanyAddress { get; set; }= "XYZ";
public string Department { get; set} = "Default Department";
public decimal Bonus { get; set}= Constants.DefaultBonus;
}

ashish shukla