¿Cómo encaja una capa de servicio en mi implementación de repositorio?

He creado una clase de modelo POCO y una clase de repositorio que maneja la persistencia. Dado que POCO no puede acceder al repositorio, hay muchas tareas de lógica de negocio en el repositorio que no parecen correctas. Por lo que he leído, parece que necesito una capa de servicio que se encuentra entre los consumidores de interfaz de usuario y la capa de repositorio. De lo que no estoy seguro es exactamente cómo se supone que funcione...

Además de la capa de servicio, también debe haber un negocio separado capa lógica, o es que el papel de la capa de servicio?

¿Debería haber un servicio por repositorio?

¿Es la capa de servicio la única forma en que la interfaz de usuario puede instigar los objetos del modelo o el repositorio proporciona la nueva instancia del modelo al servicio?

¿Pongo mi parámetro, modelo y otras validaciones en la capa de servicio que hacen cosas como comprobar para asegurarse de que una entrada es válida y que existe un elemento a actualizar en la base de datos antes de actualizar?

Puede el el modelo, el repositorio y la interfaz de usuario hacen llamadas a la capa de servicio, o es solo para que la interfaz de usuario consuma?

¿Se supone que la capa de servicio es todos los métodos estáticos?

¿Cuál sería una forma típica de llamar a la capa de servicio desde la interfaz de usuario?

¿Qué validaciones deben estar en el modelo frente a la capa de servicio?

Aquí hay un código de ejemplo para mis capas existentes:

public class GiftCertificateModel
{
    public int GiftCerticiateId {get;set;}
    public string Code {get;set;}
    public decimal Amount {get;set;}
    public DateTime ExpirationDate {get;set;}

    public bool IsValidCode(){}
}


public class GiftCertificateRepository
{
    //only way to access database
    public GiftCertificateModel GetById(int GiftCertificateId) { }
    public List<GiftCertificateModel> GetMany() { }
    public void Save(GiftCertificateModel gc) { }
    public string GetNewUniqueCode() { //code has to be checked in db }

    public GiftCertificateModel CreateNew()
    {
        GiftCertificateModel gc = new GiftCertificateModel();
        gc.Code = GetNewUniqueCode();
        return gc;
    }              
}

ACTUALIZACIÓN: Actualmente estoy usando formularios web y classic ADO.NET. Espero pasar a MVC y EF4 finalmente.

ACTUALIZACIÓN: Muchas gracias a @Lester por su gran explicación. Ahora entiendo que necesito agregar una capa de servicio para cada uno de mis repositorios. Esta capa será la ÚNICA forma en que la interfaz de usuario u otros servicios pueden comunicarse con el repositorio y contendrá cualquier validación que no quepa en el objeto de dominio (por ejemplo, validaciones que necesitan llamar al repositorio)

public class GiftCertificateService()
{

    public void Redeem(string code, decimal amount)
    {
        GiftCertificate gc = new GiftCertificate();
        if (!gc.IsValidCode(code))
        {
            throw new ArgumentException("Invalid code");
        }

        if (amount <= 0 || GetRemainingBalance(code) < amount)
        {
            throw new ArgumentException("Invalid amount");
        }

        GiftCertificateRepository gcRepo = new GiftCertificateRepository();
        gcRepo.Redeem(code, amount);
    }

    public decimal GetRemainingBalance(string code)
    {
        GiftCertificate gc = new GiftCertificate();            
        if (!gc.IsValidCode(code))
        {
            throw new ArgumentException("Invalid code");
        }

        GiftCertificateRepository gcRepo = new GiftCertificateRepository();
        gcRepo.GetRemainingBalance(code);
    }

    public SaveNewGC(GiftCertificate gc)
    {
        //validates the gc and calls the repo save method
        //updates the objects new db ID
    }

}

Preguntas

1. ¿Añado las mismas (y posiblemente más) propiedades al servicio como lo tengo en mi modelo (cantidad, código, etc) o solo ofrezco métodos que aceptan objetos GiftCertificate y parámetros directos?

2. ¿Puedo crear una instancia predeterminada de la entidad GiftCertificate cuando se llama al constructor de Servicio o simplemente crear otras nuevas según sea necesario (por ejemplo, para métodos de validación en el servicio que necesitan llamar a métodos de validación en la entidad? También, la misma pregunta sobre la creación de una instancia de repositorio predeterminada...?

3. Sé que exponga la funcionalidad del repositorio a través del servicio, ¿también expongo los métodos de la entidad también (por ejemplo, IsValidCode, etc.)?

4. Está bien que la interfaz de usuario simplemente cree un nuevo objeto GiftCertificate directamente sin pasar por el servicio (por ejemplo, para llamar a los métodos de validación de parámetros desde la entidad). Si no, ¿cómo hacerlo cumplir?

5. En la capa de interfaz de usuario, cuando quiero crear un nuevo certificado de regalo, ¿llamo a las validaciones de modelo / servicio (como IsValidExpirationDate, etc.) directamente desde la capa de interfaz de usuario O hidrato el objeto primero, luego lo paso para ser validado y luego devuelvo algún tipo de resumen de validación a la interfaz de usuario?

Además, si quiero canjear desde la capa de IU, primero llamo a los métodos de validación del modelo/servicio desde la IU para dar retroalimentación al usuario y luego llamo al método de Canjeo que ejecutará las mismas comprobaciones de nuevo internamente?

Ejemplo para llamar al servicio para realizar una operación de canje desde UI:

string redeemCode = RedeemCodeTextBox.Text;

GiftCertificateService gcService = new GiftCertificateService();
GiftCertificate gc = new GiftCertificate(); //do this to call validation methods (should be through service somehow?)

if (!gc.IsValid(redeemCode))
{
    //give error back to user
}

if (gcService.GetRemainingBalance(redeemCode) < amount)
{
    //give error back to user
}

//if no errors
gcService.Redeem(code,amount);

Ejemplo para crear un nuevo certificado de regalo desde la interfaz de usuario:

GiftCertificateService gcService = new GiftCertificateService();
GiftCertificate gc = new GiftCertificate();

if (!gc.IsValidExpDate(inputExpDate))
{
    //give error to user..
}

//if no errors...
gc.Code = gcService.GetNewCode();
gc.Amount = 10M;
gc.ExpirationDate = inputExpDate;
gcService.SaveNewGC(gc);
//method updates the gc with the new id...

Algo se siente mal sobre la forma en que se crean los GCS y cómo se separan las validaciones entre entidad/servicio. El usuario/consumidor no debe tener que preocuparse por qué validaciones están en qué lugar... ¿consejo?