No...whichever class declares itself as implementing the interface, that  
class must fully implement the interface.

Which is not to say that you can't use the class hierarchy in the  
implementation.  A base class can use virtual methods, called by the  
interface implementation, which can be overridden by derived classes.  A  
derived class can use methods from the base class, again called by the  
interface implementation.

So, using your example:

You might have something like this (showing just two properties here for  
brevity):

    class A
    {
        protected int Property1Impl
        {
            get { ... }
            set { ... }
        }
    }

    class B : A, IMyInterface
    {
        public int Property1
        {
            get { return Property1Impl; }
            set { Property1Impl = value; }
        }

        public int Property2
        {
            get { ... }
            set { ... }
        }
    }

In that example, only B actually implements the interface, but it inherits  
an implementation of the interface, used explicitly internally, from A.

Or even something like this:

    abstract class A : IMyInterface
    {
        public int Property1
        {
            get { ... }
            set { ... }
        }

        public abstract int Property2 { get; set; }
    }

    class B : A
    {
        public int Property2
        {
            get { ... }
            set { ... }
        }
    }

In this example, it's A that implements the interface, but it leaves one  
property unimplemented, requiring any derived classes to implement it.  Of  
course, this means that you can't instantiate A, because it's abstract.  
If you want to be able to instantiate A _and_ have it implement  
IMyInterface, obviously it has to have an actual implementation in class A.

In that case, a third alternative would be to make the abstract property a  
virtual property instead.  Then A has a default implementation that other  
classes can override.

Pete

It's possible IF and only IF the base class is abstract. and simply
declare the method of the interface it's implementing (but do not
provide an implementation).

The the devided class must implement the abstract members.

There is no way for the base class to not declare ALL the members of
the inteface

Parez... As answered in this thread, it is possible to implement part of
an interface in a base class and complete the implementation in the
derived class. Given an interface ISort:

   interface ISort {
       void Sort(Array array);
       int CompareTo(Object obj);
   }

You could write an abstract class that implements a complex Sort
algorithm as in:

   abstract class MySortBase : ISort
   {
       public void Sort(Array array) {
           System.Console.WriteLine("Sorted");
       } // dummy implementation
       public abstract int CompareTo(Object obj);
   }

Other coders could then use your complex sort algorithm by inheriting
from MySortBase and implementing the CompareTo method as in:

   class MySort : MySortBase
   {
       public override int CompareTo(object obj)
       {
           ....
       }
   }

Regards,
Jeff

in base class and half in derived class.<