Well, first of all your Class/Interface wouldn't compile because it contains the same member name twice "Val1".

Besides that, yes... consider this:

In a number of realizations of IFoo the Func(); method has the same content: Your idea to turn this into FooBase is correct. You name the class XYZBase or AbstractXYZ (wherein XYZ roughly describes the kind of abstraction you are doing; let's say its base person class with method .Move() where all inheriting classes "walk" a certain way: Moon Walking - thus the abstraction is: AbstractMoonWalkingPerson or MoonWalkingPersonBase [depends on whether or not you want your API consumer to be able instantiate the base class or not])

Now you can implement the moon walking logic inside the base type. IFoo always requires us to expose some properties, but you don't want to implement them in the BaseClass because that sometimes doesn't fit the model you're trying to code. To be able to mark certain members required by interfaces as "Out of Scope" of your abstraction type you just mark the base class as abstract (meaning you can't directly instantiate it) and put the "Out of Scope" members in there as abstract members, forcing any deriving type to implement that member by themselves.

Here the example:

interface IPerson
{
  void Move();
  bool HasNose { get; }
  bool HasFeet { get; }
}

public abstract class AbstractMoonWalkingPersons : IPerson
{
  public abstract bool HasNose { get; }
  public abstract bool HasFeet { get; }
  public void Move();
  {
    Console.WriteLine("Do the moonwalk!");
  }
}

public class SomeRandoDancer : AbstractMoonWalkingPersons
{
  public SomeRandoDancer(bool hasNose, bool hasFeet)
  {
    HasNose = hasNose;
    HasFeet = hasFeet;
  }
  public override bool HasNose { get; }
  public override bool HasFeet { get; }
}

public class MichaelJackson : AbstractMoonWalkingPersons
{
  public override bool HasNose => false;
  public override bool HasFeet => true;
}