How to check string is palindrome or not in .NET

public bool isPalindrome(String str)
{
    if (String.IsNullOrEmpty(str))
        return false;
 
    int length = str.Length;
 
    str = str.ToLower();
 
    for (int i = 0; i < (length / 2); i++)
    {
        if (str[i] != str[length - 1 - i])
            return false;
    }
 
    return true;
}

How to generate Fibonacci series in c#

Open a console application project in c# language in your editor and just paste the following code in your class's brackets -

static void Main(string[] args)
{
     int previous = -1; int next = 1;
     int position;
    Console.WriteLine("Enter the position");
    position = int.Parse(Console.ReadLine());
   for (int i = 0; i < position; i++)
   {
        int sum = next + previous; previous = next;
        next = sum;
       Console.WriteLine(next);
   }
   Console.ReadLine();
}

Tip: One problem with the implementation in this article is that the int types will overflow past the 47th Fibonacci number. To solve this problem, you can use the double type. Change Fibonacci() to return double. Additionally, change previous , next , and position to be of type double.

Output
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377

Indexer in C#

Indexers allow instances of a class or struct to be indexed just like arrays. Indexers resemble properties except that their accessors take parameters.
In the following example, a generic class is defined and provided with simple get and set accessor methods as a means of assigning and retrieving values. The Program class creates an instance of this class for storing strings.



class SampleCollection<T>
{
    // Declare an array to store the data elements.
    private T[] arr = new T[100];
    // Define the indexer, which will allow client code
    // to use [] notation on the class instance itself.
    // (See line 2 of code in Main below.)       
    public T this[int i]
    {
        get
        {
            // This indexer is very simple, and just returns or sets
            // the corresponding element from the internal array.
            return arr[i];
        }
        set
        {
            arr[i] = value;
        }
    }
}
// This class shows how client code uses the indexer.
class Program
{
    static void Main(string[] args)
    {
        // Declare an instance of the SampleCollection type.
        SampleCollection<string> stringCollection = new SampleCollection<string>();
        // Use [] notation on the type.
        stringCollection[0] = "My Name is Psingh";
        System.Console.WriteLine(stringCollection[0]);
    }
}

Output:
"My Name is Psingh"


 

Comparison Between Properties and Indexers

Indexers are similar to properties. Except for the differences shown in the following table, all of the rules defined for property accessors apply to indexer accessors as well.

Property	Indexer
Identified by its name.	Identified by its signature.
Accessed through a simple name or a member access.	Accessed through an element access.
Can be a static or an instance member.	Must be an instance member.
A get accessor of a property has no parameters.	A get accessor of an indexer has the same formal parameter list as the indexer.
A set accessor of a property contains the implicit value parameter.	A set accessor of an indexer has the same formal parameter list as the indexer, in addition to the value parameter.

IQueryable vs. IEnumerable in terms of LINQ to SQL queries

IQueryable inherited IEnumerable, so it obviously get all the functionality IEnumerable has. The working style of both is still different. There are still lot many differences exists between the two which impact the decision we took in usage of either one. Both of these suits for particular scenarios. Following are some differences using which we can took decision to use anyone of these optimally.

Parameter	IQueryable	IEnumerable
Extension Methods	Extension methods defined for IQueryable take expression objects. Means, the delegate IQueryable extension methods receives is an expression tree.	Extension methods defined for IEnumerable take functional objects. Means, the delegate IEnumerable extension methods receives is a method to invoke.
Great For	IQueryable allows out-of-memory things like remote data source operations, such as working with database or web service.	IEnumerable is great for working with sequences (in-memory collections), that are iterated in-memory.
Supported Queries	IQueryable supports LINQ to SQL queries.	IEnumerable supports LINQ to Object and LINQ to XML queries.
Deferred Execution	IQueryable supports lazy loading (Suited for scenarios like paging and composition based queries).	IEnumerable lost lazy loadnig ability on the external provider.
Moving between items	IQueryable provides many methods to move between the items.	IEnumerable doesn’t have the concept of moving between items, it is forward only collection.
Filtering Mechanism	IQueryable executes query on server side along with all the filters applied.	IEnumerable executes select query on server side, loads data in-memory and then executes filter at client side.
CreateQuery and Execute Methods	IQueryable has these two additional methods. Both takes expression as input. CreateQuery returns IQueryable representing expression tree. Execute returns result of the query.	NA
Custom Querying Capability	IQueryable provides additional functionality to implement custom querying with LINQ.	IEnumerable does not have custom querying capability.
Performance Perspective	IQueryable gives best performance when used for out-of-memory data store operations (that is external to .NET CLR memory).	IEnumerable gives best performance when used to manipulate in-memory collections.

IEnumerable: IEnumerable is best suitable for working with in-memory collection. IEnumerable doesn’t move between items, it is forward only collection.
IQueryable: IQueryable best suits for remote data source, like a database or web service. IQueryable is a very powerful feature that enables a variety of interesting deferred execution scenarios (like paging and composition based queries).


So when you have to simply iterate through the in-memory collection, use IEnumerable, if you need to do any manipulation with the collection like Dataset and other data sources, use IQueryable