List

 What is C# List<T>

  • List<T> class represents the list of objects which can be accessed by index. It comes under the System.Collection.Generic namespace. 
  • List class can be used to create a collection of different types like integers, strings etc. List<T> class also provides the methods to search, sort, and manipulate lists.
  • It is different from the arrays. A List<T> can be resized dynamically but arrays cannot.
  • List<T> class can accept null as a valid value for reference types and it also allows duplicate elements.
  • If the Count becomes equals to Capacity, then the capacity of the List increased automatically by reallocating the internal array. The existing elements will be copied to the new array before the addition of the new element.
  • List<T> class is the generic equivalent of ArrayList class by implementing the IList<T> generic interface.
  • This class can use both equality and ordering comparer.
  • List<T> class is not sorted by default and elements are accessed by zero-based index.
  • For very large List<T> objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the configuration element to true in the run-time environment.

Properties


 
Properties            		 Description 
 Capacity     Gets or sets the total number of elements the internal data structure can hold without resizing.
 Count Returns the total number of elements exists in the List<T>    
 Item Gets or sets the element at the specified index.


Methods


 Method     Usage    
 Add     Adds an element at the end of a List<T>.    
 AddRange     Adds elements of the specified collection at the end of a List<T>.        
 BinarySearch Search the element and returns an index of the element.
 Clear Removes all the elements from a List<T>.
 Contains Checks whether the speciied element exists or not in a List<T>
 Find Finds the first element based on the specified predicate function.
 ForEach Iterates through a List<T>.
 Remove<T>     Removes the first occurrence of a specific object from the List<T>.
 Remove All<T>            Removes all the elements that match the conditions defined by the specified predicate.
 Remove At(Int32) Removes the element at the specified index of the List<T>.
 RemoveRange(Int32,Int32)  Removes a range of elements from the List<T>.
 Reverse() Reverses the order of the elements in the List<T> or a portion of it.
 Sort()Sorts the elements or a portion of the elements in the List<T> using either the specified or default IComparer<T> implementation or a provided Comparison<T> delegate to compare list elements.    
 ToArray() Copies the elements of the List<T> to a new array.


Example:

class CollectionExamples
    {
        public static void Main(String[] args)
        {

            // Creating an List<T> of Integers 
            List<int> _List = new List<int>();

            // Adding elements to List 
            _List.Add(1);
            _List.Add(3);
            _List.Add(4);
            _List.Add(7);
            _List.Add(9);
            _List.Add(18);
            _List.Add(22);

            Console.WriteLine("Elements Present in List:\n");

            int p = 0;

            // Displaying the elements of List 
            foreach (int k in _List)
            {
                Console.Write("At Position {0}: ", p);
                Console.WriteLine(k);
                p++;
            }

            Console.WriteLine(" ");

            // removing the element at index 3 
            Console.WriteLine("Removing the element at index 3\n");
            _List.RemoveAt(4);

            int p1 = 0;

            // Displaying the elements of List 
            foreach (int n in _List)
            {
                Console.Write("At Position {0}: ", p1);
                Console.WriteLine(n);
                p1++;
            }
        }
By at No comments:
Labels:

Queue(Non Generic)

Queue:

C# includes a Queue collection class in the System.Collection namespace. Queue stores the elements in FIFO style (First In First Out), exactly opposite of the Stack collection. It contains the elements in the order they were added.

Queue collection allows multiple null and duplicate values.

Use the Enqueue() method to add elements into Queue

The Dequeue() method returns and removes elements from the beginning of the Queue. Calling the Dequeue() method on an empty queue will throw an exception.

The Peek() method always returns top most element.


Properties of queue

Count - Returns the total count of elements in the Queue.

Methods of queue

  1. Enqueue: Adds an item into the queue.
  2. Dequeue: Removes and returns an item from the beginning of the queue.
  3. Peek: Returns an first item from the queue
  4. Contains: Checks whether an item is in the queue or not
  5. Clear: Removes all the items from the queue.
  6. TrimToSize: Sets the capacity of the queue to the actual number of items in the queue.



1.Enqueue: Enqueue method is used to add element in queue.you can add element of any datatype as it's a non-generic collection.

Example

 class CollectionExamples
    {
        static void Main(string[] args)
        {
            Queue _queue = new Queue();
            _queue.Enqueue(1);
            _queue.Enqueue(2);
            _queue.Enqueue(3);
            _queue.Enqueue(3); //it allows duplicate
            _queue.Enqueue(null); // it allows null

            foreach(var item in _queue)
            {
                Console.WriteLine(item);
            }
            
            Console.ReadLine();
        }
    }

2.Dequeue: 
Dequeue() method is used to retrieve the top most element in a queue collection.

Dequeue() removes and returns a first element from a queue because the queue stores elements in FIFO order.
 
Calling Dequeue() method on empty queue will throw InvalidOperation exception. So always check that the total count of a queue is greater than zero before calling the Dequeue() method on a queue.

Example

 class CollectionExamples
    {
        static void Main(string[] args)
        {
            Queue _queue = new Queue();
            _queue.Enqueue(1);
            _queue.Enqueue(2);
            _queue.Enqueue(3);
            _queue.Enqueue(3); //it allows duplicate
            _queue.Enqueue(null); // it allows null


           Console.WriteLine("Length Before Dequeue {0}", _queue.Count);
           Console.WriteLine("Calling Dequeue {0}", _queue.Dequeue()); //Return first element and remove it.
           Console.WriteLine("Length After Dequeue {0}", _queue.Count);

            Console.ReadLine();
        }
    }

Output:

Length Before Dequeue 5
Calling Dequeue 1
Length After Dequeue 4


3. Peek() : The Peek() method always returns the first item from a queue collection without removing it from the queue. 

Calling Peek() and Dequeue() methods on an empty queue collection will throw a run time exception "InvalidOperationException".

Example

 class CollectionExamples
    {
        static void Main(string[] args)
        {
            Queue _queue = new Queue();
            _queue.Enqueue(1);
            _queue.Enqueue(2);
            _queue.Enqueue(3);
            _queue.Enqueue(3); //it allows duplicate
            _queue.Enqueue(null); // it allows null


           Console.WriteLine("Length Before Dequeue {0}", _queue.Count);
           Console.WriteLine("Calling Dequeue {0}", _queue.Peek()); //Return first element
           Console.WriteLine("Length After Dequeue {0}", _queue.Count);

            Console.ReadLine();
        }
    }

Output

Length Before Dequeue 5
Calling Dequeue 1
Length After Dequeue 5


4.Contains()
The Contains() method checks whether an item exists in a queue. It returns true if the specified item exists; otherwise it returns false.

Example

 class CollectionExamples
    {
        static void Main(string[] args)
        {
            Queue _queue = new Queue();
            _queue.Enqueue(1);
            _queue.Enqueue(2);
            _queue.Enqueue(3);
            _queue.Enqueue(3); //it allows duplicate
            _queue.Enqueue(null); // it allows null


           Console.WriteLine(_queue.Contains(1)); // it will return true
        

            Console.ReadLine();
        }
    }


5.Clear() :The Clear() method removes all the items from a queue.

Example

 static void Main(string[] args)
        {
            Queue _queue = new Queue();
            _queue.Enqueue(1);
            _queue.Enqueue(2);
            _queue.Enqueue(3);
            _queue.Enqueue(3); //it allows duplicate
            _queue.Enqueue(null); // it allows null

            _queue.Clear();
           Console.WriteLine(_queue.Count);//it will return 0
        

            Console.ReadLine();
        }

By at No comments:
Labels: , ,

Stack(Non generic)

C# Stack

C# includes a special type of collection which stores elements in LIFO style (Last In First Out).

Stack allows null value and also duplicate values. It provides a Push() method to add a value and Pop() or Peek() methods to retrieve values.

Use the Push() method to add elements into Stack.

The Pop() method returns and removes elements from the top of the Stack. Calling the Pop() method on the empty Stack will throw an exception.

The Peek() method always returns top most element in the Stack.

Properties

Count- Return the total count of element in the stack.

Method

  1. Push: Inserts an item at the top of the stack.
  2. Peek: Returns the top item from the stack.
  3. Pop: Removes and returns items from the top of the stack.
  4. Contains: Checks whether an item exists in the stack or not.
  5. Clear: Removes all items from the stack.

1. Push: The Push() method adds values into the Stack. It allows value of any datatype

Example:

  static void Main(string[] args)
        {
            Stack _stack = new Stack();
            _stack.Push(1);
            _stack.Push(2);
            _stack.Push(3);

            foreach (var item in _stack)
            Console.WriteLine(item);
            Console.ReadLine();

        }

2.Peek: The Peek() method returns the last (top-most) value from the stack. Calling Peek() method on empty stack will throw InvalidOperationException. So always check for elements in the stack before retrieving elements using the Peek() method.

The below program return 4 as an output.

Example
class CollectionExamples
    {
        static void Main(string[] args)
        {
            Stack _stack = new Stack();
            _stack.Push(1);
            _stack.Push(2);
            _stack.Push(3);
            _stack.Push(4);
            Console.WriteLine(_stack.Peek());
            Console.ReadLine();

        }
    }

3.Pop(): You can also retrieve the value using the Pop() method. The Pop() method removes and returns the value that was added last to the Stack. The Pop() method call on an empty stack will raise an InvalidOperationException. So always check for number of elements in stack must be greater than 0 before calling Pop() method.

Below program retrurn 3,2 and  1 as an output.
Example

 class CollectionExamples
    {
        static void Main(string[] args)
        {
            Stack _stack = new Stack();
            _stack.Push(1);
            _stack.Push(2);
            _stack.Push(3);
            _stack.Push(4);
            _stack.Pop();
            foreach (var item in _stack)
                Console.WriteLine("items {0}", item);
            Console.ReadLine();

        }
    }
    
4.Contains():The Contains() method checks whether the specified item exists in a Stack collection or not. It returns true if it exists; otherwise it returns false.

Below program return true as an output.

class CollectionExamples
    {
        static void Main(string[] args)
        {
            Stack _stack = new Stack();
            _stack.Push(1);
            _stack.Push(2);
            _stack.Push(3);
            _stack.Push(4);
            Console.WriteLine("Is Exist : {0}", _stack.Contains(1));
            Console.ReadLine();
        }
    }


5.Clear() :The Clear() method removes all the values from the stack.

class CollectionExamples
    {
        static void Main(string[] args)
        {
            Stack _stack = new Stack();
            _stack.Push(1);
            _stack.Push(2);
            _stack.Push(3);
            _stack.Push(4);

           _stack.clear();
            Console.WriteLine("Total {0}",_stack.count);
            Console.ReadLine();
        }
By at No comments:
Labels: , ,

Sorted List(Non generic)

C# Sorted List(Non generic)


In C#, SortedList is a collection of key/value pairs which are sorted according to keys. By default, this collection sort the key/value pairs in ascending order.
Non-generic SortedList is defined under System.Collections namespace

Properties of Sorted List

  1. Capacity: Gets or sets the number of elements that the SortedList instance can store.
  2. Count: Gets the number of elements actually contained in the SortedList.
  3. IsFixedSize: Gets a value indicating whether the SortedList has a fixed size.
  4. IsReadOnly: Gets a value indicating whether the SortedList is read-only.
  5. Item : Gets or sets the element at the specified key in the SortedList.
  6. Keys: Get list of keys of SortedList.
  7. Values: Get list of values in SortedList.


Method of Sorted List

1) Add(object key, object value): Add key-value pairs into SortedList.
Key cannot be null but value can be null. Also, datatype of all keys must be same, so that it can compare otherwise it will throw runtime exception.

Non-generic SortedList collection can contain key and value of any data type. So values must be cast to the appropriate data type otherwise it will give compile-time error.

Example:

class CollectionExamples
    {
        static void Main(string[] args)
        {

            SortedList sl = new SortedList();
            sl.Add(3, "Three");
            sl.Add(1, "One");
            sl.Add(2, "Two");
            sl.Add(4, null);

            foreach (var item in sl.Keys)
            {
                Console.WriteLine("Sorted List {0}", item);
            }
            Console.ReadLine();

        }
    }

Output:
Sorted List 1
Sorted List 2
Sorted List 3
Sorted List 4

2) Remove(object key): Removes element with the specified key.
3) RemoveAt(int index): Removes element at the specified index.

Example

 static void Main(string[] args)
        {

            SortedList sl = new SortedList();
            sl.Add(3, "Three");
            sl.Add(1, "One");
            sl.Add(2, "Two");
            sl.Add(4, null);

            sl.Remove(3);//Remove element whose key is two
            sl.RemoveAt(0);//Remove element whose index is 1
            foreach (DictionaryEntry de in sl)
            {
                Console.WriteLine("Sorted List {0}", de.Key);
            }
            Console.ReadLine();

        }

Output:

Sorted List 2
Sorted List 4


4)Contains: This method is used to check whether a SortedList object contains a specific key.
5)ContainsKey: This method is used to check whether a SortedList object contains a specific key.
6)ContainsValue: This method is used to check whether a SortedList object contains a specific value.

Example:

        static void Main(string[] args)
        {

            SortedList sl = new SortedList();
            sl.Add(3, "Three");
            sl.Add(1, "One");
            sl.Add(2, "Two");
            sl.Add(4, null);

            Console.WriteLine("Contains {0}",sl.Contains(3)); // Return true if given key is found.
            Console.WriteLine("Contains Key {0}", sl.ContainsKey(3));// Return true if given key is found.
            Console.WriteLine("Contains value {0}", sl.ContainsValue("Three"));//Return true if given value found.
            
            Console.ReadLine();

        }


GetByIndex(int index) : Returns the value by index stored in internal array
GetKey(int index): Returns the key stored at specified index in internal array
IndexOfKey(object key): Returns an index of specified key stored in internal array
IndexOfValue(object value) : Returns an index of specified value stored in internal array


Note:Internally, SortedList maintains two object[] array, one for keys and another for values. So when you add key-value pair, it runs a binary search using the key to find an appropriate index to store a key and value in respective arrays. It re-arranges the elements when you remove the elements from it.


By at 1 comment:
Labels: ,

HashTable in C#


What is HashTable?


C# includes Hashtable collection in System.Collections namespace, which is similar to generic collection. The Hashtable collection stores key-value pairs. It optimizes lockups by computing the hash code of each key and stores it in a different bucket internally and then matches the hash code of the specified key at the time of accessing values.

Properties of Hashtable

Count: Gets the total count of key/value pairs in the Hashtable.
IsReadOnly: Gets boolean value indicating whether the Hashtable is read-only.
Item :Gets or sets the value associated with the specified key.
Keys :Gets an ICollection of keys in the Hashtable.
Values : Gets an ICollection of values in the Hashtable

Methods of HashTable

Add : The Add() method adds an item with a key and value into the Hashtable. Key and value can be of any data type. Key cannot be null whereas value can be null.

Example
static void Main(string[] args)
         {

            Hashtable ht = new Hashtable();
            ht.Add(1, "One");
            ht.Add(2, 2);
            ht.Add(3, 3.0);
            ht.Add(4, null);
        }

Remove: Removes the item with the specified key from the hashtable.

Example
static void Main(string[] args)
         {

            Hashtable ht = new Hashtable();
            ht.Add(1, "One");
            ht.Add(2, 2);
            ht.Add(3, 3.0);
            ht.Add(4, null);

            ht.Remove(1);
        }

Clear: Removes all the items from the hashtable.
Example

 static void Main(string[] args)
         {

            Hashtable ht = new Hashtable();
            ht.Add(1, "One");
            ht.Add(2, 2);
            ht.Add(3, 3.0);
            ht.Add(4, null);

            ht.Clear();
        }


Contains: Checks whether the hashtable contains a specific key.
Example

 static void Main(string[] args)
         {

            Hashtable ht = new Hashtable();
            ht.Add(1, "One");
            ht.Add(2, 2);
            ht.Add(3, 3.0);
            ht.Add(4, null);

            ht.Contains(1);//return true;
            ht.Contains(1);//return true;
            ht.Contains(5); //return false
        }

ContainsKey: Checks whether the hashtable contains a specific key it work similar as Contains.

ContainsValue: Checks whether the hashtable contains a specific value.

 static void Main(string[] args)
         {

            Hashtable ht = new Hashtable();
            ht.Add(1, "One");
            ht.Add(2, 2);
            ht.Add(3, 3.0);
            ht.Add(4, null);
            ht.ContainsValue(5); //return true
        }

GetHash: Returns the hash code for the specified key.




Summary:

  • Hashtable stores key-value pairs of any datatype where the Key must be unique.
  • The Hashtable key cannot be null whereas the value can be null.
  • Hashtable retrieves an item by comparing the hashcode of keys. So it is slower in performance than Dictionary collection.
  • Hashtable uses the default hashcode provider which is object.GetHashCode(). You can also use a custom hashcode provider.
  • Use DictionaryEntry with foreach statement to iterate Hashtable.


By at 1 comment:
Labels:

Array List

What is Array List?

ArrayList is a non-generic type of collection in C#. It can contain elements of any data types. It is similar to an array, except that it grows automatically as you add items in it. Unlike an array, you don't need to specify the size of ArrayList.

the ArrayList class implements IEnumerable, ICollection, and IList interfaces. So, you can create an object of ArrayList class and assign it to the variable of any base interface type. However, if you assign it to IEnumerable or ICollection type variable then you won't be able to add elements and access ArrayList by index.

For Ex:

     class CollectionExamples
    {
        static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();//can add elements with additional methods
            IList _ArrayIList = new ArrayList();//can add elements
            ICollection _ArrayICollection = new ArrayList();//can not add elements
            IEnumerable _ArrayIEnumerable = new ArrayList();//can not add elements

      
        }
    }

From above example you can see that using ArrayList is more useful compare to others.because ArrayList class contains some additional methods which are not the members of IList interface such as AddRange(), BinarySearch(), Repeat(), Reverse(), etc.

Properties of ArrayList

  1. Capicity: Gets or sets the number of elements that the ArrayList can contain
  2. Count:Gets the number of elements actually contained in the ArrayList.
  3. IsFixedSize: Gets a value indicating whether the ArrayList has a fixed size.
  4. IsReadOnly: Gets a value indicating whether the ArrayList is read-only.
  5. Item:Gets or sets the element at the specified index.

Methods Of ArrayList

1.Add()/AddRange: Add() method adds single elements at the end of ArrayList.
AddRange() method adds all the elements from the specified collection into ArrayList

 Example:

class CollectionExamples
    {
        static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();
            ArrayList _ArrayList2 = new ArrayList();
            _ArrayList.Add(1);
            _ArrayList.Add("Two");
            _ArrayList.Add(2.5);
            _ArrayList.Add(3.5f);

            _ArrayList2.AddRange(_ArrayList);//Adding entire collection

            Console.WriteLine("Array List 1 Count {0}", _ArrayList.Count);
            Console.WriteLine("Array Lisr 2 Count {0}", _ArrayList2.Count);
            Console.ReadLine();

        }
    }
                                                                                                                                                            




2.Insert()/InsertRange():

Insert() method insert a single elements at the specified index in ArrayList.
InsertRange() method insert all the elements of the specified collection starting from specified index in ArrayList.       

Example:   

 class CollectionExamples
    {
        static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();
            ArrayList _ArrayList2 = new ArrayList();

            _ArrayList.Add(1);
            _ArrayList.Add("Two");
            _ArrayList.Add(2.5);
            _ArrayList.Add(3.5f);
            _ArrayList.Insert(1, "Inserted"); // Inserted Single item at particular index

            _ArrayList2.AddRange(_ArrayList);
            _ArrayList2.InsertRange(3,_ArrayList); //Insert entire list from the particular index.

            foreach(var i in _ArrayList)
            {
                Console.WriteLine("Items in ArrayList - 1 {0}", i);
            }
            foreach (var i in _ArrayList2)
            {
                Console.WriteLine("Items in ArrayList - 2 {0}", i);
            }
            Console.WriteLine("Array List 1 Count {0}", _ArrayList.Count);
            Console.WriteLine("Array Lisr 2 Count {0}", _ArrayList2.Count);
            Console.ReadLine();

        }
    }
    
                                                                                                                                                            

3.Remove()/Remove Range():
Remove() method removes the specified element from the ArrayList.
RemoveRange() method removes a range of elements from the ArrayList.

  static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();
            ArrayList _ArrayList2 = new ArrayList();

            _ArrayList.Add(1);
            _ArrayList.Add("Two");
            _ArrayList.Add(2.5);
            _ArrayList.Add(3.5f);
            _ArrayList.Remove(1); //Remove 1 from Arraylist


            _ArrayList2.AddRange(_ArrayList);
            _ArrayList2.Add("New Values");
            _ArrayList2.RemoveRange(0,3);//Remove 3 element starting from 0th.
          

            foreach(var i in _ArrayList)
            {
                Console.WriteLine("Items in ArrayList - 1 {0}", i);
            }
            foreach (var i in _ArrayList2)
            {
                Console.WriteLine("Items in ArrayList - 2 {0}", i);
            }
            Console.WriteLine("Array List 1 Count {0}", _ArrayList.Count);
            Console.WriteLine("Array Lisr 2 Count {0}", _ArrayList2.Count);
            Console.ReadLine();

        }

                                                                                                                                                        


4.RemoveAt():

Removes the element at the specified index from the ArrayList.

Example  

static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();
            ArrayList _ArrayList2 = new ArrayList();

            _ArrayList.Add(1);
            _ArrayList.Add("Two");
            _ArrayList.Add(2.5);
            _ArrayList.Add(3.5f);
            _ArrayList.RemoveAt(2); //Remove 2 index element from Arraylist

            foreach(var i in _ArrayList)
            {
                Console.WriteLine("Items in ArrayList - 1 {0}", i);
            }
 
            Console.ReadLine();

        }
                                                                                                                                                         

5.Sort & Reverse():

The ArrayList class includes Sort() and Reverse() method. The Sort() method arranges elements in ascending order. However, all the elements should have same data type so that it can compare with default comparer otherwise it will throw runtime exception.

The Reverse() method arranges elements in reverse order. Last element at zero index and so on.

Example:

   static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();
         

            _ArrayList.Add(1);
            _ArrayList.Add(2);
            _ArrayList.Add(2);
            _ArrayList.Add(3);
            
            _ArrayList.Sort(); // Sorting
            foreach(var i in _ArrayList)
            {
                Console.WriteLine("Items in ArrayList - 1 {0}", i);
            }
            _ArrayList.Reverse(); //Reverse
            foreach (var i in _ArrayList)
            {
                Console.WriteLine("Items in ArrayList - 1 {0}", i);
            }
            Console.ReadLine();

        }                                                                                                                                                            


6.Contains

The Contains() method checks whether specified element exists in the ArrayList or not. Returns true if exists otherwise false.

Example:

 static void Main(string[] args)
        {
            ArrayList _ArrayList = new ArrayList();

            _ArrayList.Add(1);
            _ArrayList.Add(2);
            _ArrayList.Add(2);
            _ArrayList.Add(3);
         
            _ArrayList.Sort();
            Console.WriteLine(_ArrayList.Contains(3)); //Print true
            Console.ReadLine();

        }


By at No comments:
Labels: ,

C# Types of classes.

Hello friends,
Here we will discuss on types of classes in c#.

There are four different types of classes available in C#. They are as follows:

1. Static class
2. Abstract class
3. Partial class
4. Sealed class

Static class:

A class with static keyword that contains only static members is defined as static class. A static class cannot be instantiated.

Characteristics of static class

  • Static class cannot instantiated using a new keyword.
  • Static items can only access other static items. For example, a static class can only contain static members, e.g. variable, methods etc.
  • A static method can only contain static variables and can only access other static items.
  • Static items share the resources between multiple users.
  • Static cannot be used with indexers, destruction or types other than classes.
  • A static constructor in a non-static class runs only once when the class is instantiated for the first time.
  • A static constructor in a static class runs only once when any of its static members accessed for the first time.
  • Static members are allocated in a high frequency heap area of the memory.


Abstract class

A class with abstract modifier indicate that class is abstract class. An abstract class cannot be instantiated. The purpose of an abstract class is to provide a common definition of a base class that multiple derived classes can share.

Characteristic of Abstract class

  • An abstract class cannot be instantiated.
  • An abstract class may contain abstract methods and accessorizes.
  • It is not possible to modify an abstract class with the sealed modifier because the two modifiers have opposite meanings. The sealed modifier prevents a class from being inherited and the abstract modifier requires a class to be inherited.
  • A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.


Partial class

  • The partial keyword indicates that other parts of the class, struct, or interface can be defined in the namespace. All the parts must use the partial keyword. All the parts must be available at compile time to form the final type. All the parts must have the same accessibility, such as public, private, and so on.

Characteristic of Partial class

  • All the partial class definitions must be in the same assembly and namespace.
  • All the parts must have the same accessibility like public or private, etc.
  • If any part is declared abstract, sealed or base type then the whole class is declared of the same type.
  • Different parts can have different base types and so the final class will inherit all the base types.
  • The Partial modifier can only appear immediately before the keywords class, struct, or interface.
  • Nested partial types are allowed.


Sealed class

A class with sealed keyword indicates that class is sealed to prevent inheritance. Sealed class cannot inheritance.

By at No comments:
Labels: ,
Subscribe to: Posts (Atom)

Jagged Array

What is Jagged Array? Jagged array is called as "array of arrays". when you need a data inside your array element at that time you...

  • Ref and Out
    What is Ref and Out Keyword? Ref and out keywords in C# are used to pass arguments within a method or function. Both indicate that an argume...
  • Sorted List(Non generic)
    C# Sorted List(Non generic) In C#, SortedList is a collection of key/value pairs which are sorted according to keys. By default, this collec...
  • Dictionary
    C# Dictionary The Dictionary<TKey, TValue> class is a generic collection class in the System.Collection.Generics namespace. TKey denot...