¿Se puede implementar una interfaz en una clase Linq2Sql?

Question

Tengo una interfaz llamada IAddress, y una clase llamada Dirección que maneja calle, ciudad, estado/provincia, código postal y país. Tengo un par de clases de Linq2Sql que tienen toda la información de dirección y me gustaría implementar la interfaz IAddress, y pasar eso al constructor para la dirección que cargaría los valores de la propiedad.

¿Es posible tener una clase de clase Linq2Sql e interfaz a través de la clase parcial que creé para él? ¡Gracias por adelantado!

Comentarios adicionales

En mi clase tengo una propiedad llamada MailToStreet, quiero que asignar a IAddress.Street. ¿Hay alguna manera de hacer esto en la clase parcial?

Resuelto

Gracias StackOverflow comunidad! ¡Fue un chasquido! Aquí está mi código final:

public partial class Location : IAddress 
{ 
    string IAddress.Street 
    { 
     get { return this.Street; } 
     set { this.Street = value; } 
    } 

    string IAddress.City 
    { 
     get { return this.City; } 
     set { this.City = value; } 
    } 

    string IAddress.StateProvince 
    { 
     get { return this.StateProvince; } 
     set { this.StateProvince = value; } 
    } 

    string IAddress.PostalCode 
    { 
     get { return this.PostalCode; } 
     set { this.PostalCode = value; } 
    } 

    string IAddress.Country 
    { 
     get { return this.Country; } 
     set { this.Country = value; } 
    } 
} 

Answer 1

clases LinqToSql son las clases parciales, lo que puede tener un archivo adicional que implementa la interfaz para la clase LinqToSql.

Sólo añadir esto a un nuevo archivo, utilizando el mismo nombre de la clase como la clase de LinqToSql:

public partial class LinqToSqlClass : IFoo { 
    public void Foo() { 
     // implementation 
    } 
} 

Si su clase LinqToSql ya implementa los proporties necesarias que debe ser capaz de incluir sólo la declaración de interfaz.

Para responder al comentario sobre el uso de una propiedad LinqToSQL de nombre diferente para implementar la interfaz, puede usar la sintaxis anterior y simplemente llamar a la propiedad LinqToSQL desde la propiedad de la interfaz, o para mantener las cosas un poco más limpias.

public partial class LinqToSqlClass : IFoo { 
    void IFoo.Foo() { 
     return this.LinqFoo(); // assumes LinqFoo is in the linq to sql mapping 
    } 
} 

mediante el uso de esta sintaxis, los clientes que acceden a su clase no van a ver una propiedad redundante utilizado sólo para la implementación de una interfaz (que será invisible a menos que el objeto se echó a esa interfaz)