Default parameter is still empty string

I have a class that inherits from Interface with this definition

public interface IModel
    {
        List<KeyValuePair<string, string>> AddValuePairs(string prefix = "");
    }

All is fine but when I call the method and pass a prefix it still sees it as empty.

public sealed class AuthURLInputModel : IModel 
	{
		public string Username {get;set;}
		public string Idnumber {get;set;}

		public List<KeyValuePair<string,string>> AddValuePairs(string prefix="user")
		{
            var pre = !string.IsNullOrEmpty(prefix) ? prefix : string.Empty;
            var keyValuePairs = new List<KeyValuePair<string, string>>
            {
                new KeyValuePair<string, string>(ModelHelper.GetPrefixedName("username", prefix), Username),
                new KeyValuePair<string, string>(ModelHelper.GetPrefixedName("idnumber", prefix), Idnumber)
            };
            return keyValuePairs;
		}

	}

Calls to

> AddValuePairs(string prefix = "user[0]")

still sees prefix as empty string instead of

> "user[0]"

that was passed in.

protected TModel Post<TModel, TInputModel>(string funcName, TInputModel inputModel)
            where TInputModel : IModel
{
  var inputs = inputModel.AddValuePairs();
}

Where TInputModel is AuthURLInputModel
Any suggestion?

The default value for optional parameters is used at compile-time, based on the compile-time type of the expression of the target of the method call. In this case, the compile-time type is TInputModel, but the compiler only "knows" about the declaration in the interface, so that's how it determines which value to use by default.

Here's a simpler, complete example:

using System;

public interface IFoo
{
    void M(int x = 0);
}

public class Foo : IFoo
{
    public void M(int x = 10)
    {
        Console.WriteLine(x);
    }
}

class Test
{
    static void Main()
    {
        Foo foo1 = new Foo();
        IFoo foo2 = foo1;

        // Prints 10, because the compiler knows
        // about the declaration of Foo.M
        foo1.M();
        // Prints 0, because the compiler only
        // knows about the declaration of IFoo.M
        foo2.M();
    }
}

I would strongly advise you not to change the default value in interface-implementing (or base-class-overriding) methods. It causes confusion - as your question demonstrates.