In oops we can't give implementation of interfaces rather we just allowed to give signature i.e. declaration only. Now my question is that we have interfaces like IEnumerator, IDisposible etc we use their methods like

IEnumerator ie = list.GetEnumerator();

ie.GetNext();

so how Interface method like GetNext() definition is defined here?

it's based on what ypu need and based on your need.

the interface is a logic e.g all of the car in whole world should put the  speed pedal on right side of the foot , any body can changethe logic . each car company should implement this interface . these interfaces type became like a law , and any body can changed it , if one wanted to change it he should first change the whole world people mind to changing speed pedal to another side .

but some of interfaces bavaive based on your application like you want to implement a ienumerable interface and you want to implement getEnum... I can implemenmt it in my needs and you should implement it asyou want , there is no limitation in implementing interfaces

look at one sample here : http://msdn.microsoft.com/en-us/library/system.collections.ienumerable.aspx

please let me know whats happen to your aplication after this information . and mark this as answer if the answer was right.

My question was that, If I create Interface like

interface ISetter { public SetValue(object); } 

I am not allowed to give implmentation inside interface rather I can just give its defination in inherited class.

but If we look on interfaces like IEnumerator, IDisposible, IList etc their methods are pre-implemented and we can directly access them by

Interface.MethodName(). eg. IEnumerator.GetNext(); How it is possible?

The methods are not implemented, the signature of the methods are implemented:

If you look at IEnumberator you see the following and note the methods are empty shells.

namespace System.Collections
{
    // Summary:
    //     Supports a simple iteration over a nongeneric collection.
    [ComVisible(true)]
    [Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
    public interface IEnumerator
    {
        // Summary:
        //     Gets the current element in the collection.
        //
        // Returns:
        //     The current element in the collection.
        //
        // Exceptions:
        //   System.InvalidOperationException:
        //     The enumerator is positioned before the first element of the collection or
        //     after the last element.
        object Current { get; }

        // Summary:
        //     Advances the enumerator to the next element of the collection.
        //
        // Returns:
        //     true if the enumerator was successfully advanced to the next element; false
        //     if the enumerator has passed the end of the collection.
        //
        // Exceptions:
        //   System.InvalidOperationException:
        //     The collection was modified after the enumerator was created.
        bool MoveNext();
        //
        // Summary:
        //     Sets the enumerator to its initial position, which is before the first element
        //     in the collection.
        //
        // Exceptions:
        //   System.InvalidOperationException:
        //     The collection was modified after the enumerator was created.
        void Reset();
    }
}

ya i've look at IEnumerator interface definition, its methods are empty however i can use without overriding them cause some where internally its methods definition is hidden but where ? Like

IEnumerator ie = Object.GetType().GetMethods();

while(ie.GetNext())

{

 ie.Current; 

} 

 I haven't done any thing just use its method GetNext() and property Current. I want to know where its implementation is hidden?  so  that i can  make interface whose methods are pre-implemented and i can use its methods just by giving InterfaceObject.MethodName(). I hope now you will understand my point of view.
 

 I think you're confused.  Theres a difference between the interface IEnumerable and a class which implements IEnumerable.  In the example you give, you're really accessing the implementation defined by a class which implements IEnumerable.  To do what you want to do, use an abstract class.