Convenciones en el código de asignación?

Question

Tengo dos clases, A y B. B sabe acerca de A, y A no sabe acerca de B. B tiene propiedades que se pueden configurar muy bien desde A, aunque no hay herencia compartida entre A y B. Habrá muchas veces cuando necesito asignar propiedades de B desde una A, pero estoy buscando punteros sobre dónde debería poner ese código.

public class A 
{ 

} 

public class B 
{ 
    //constructor? 
    public B(A a) 
    { 
     //set b's properties from a 
    } 

    //factory method? 
    public static B FromA(A a) 
    { 
     B b = new B(); 
     //set b's properties from a 
     return b; 
    } 

    //setter method? 
    public static void SetBFromA(B b, A a) 
    { 
     //set b's properties from a 
    } 

    //assignment method? 
    public void AssignFrom(A a) 
    { 
     //set b's properties from a 
    } 
} 

//static helper class? 
public static class BHelper 
{ 
    public static B GetBFromA(A a) 
    { 
     B b = new B(); 
     //set b's properties from a 
     return b; 
    } 

    public static void SetBFromA(B b, A a) 
    { 
     //set b's properties from a 
    } 
} 

¿Cuál de estas, si las hay, son una práctica común? ¿Alguno de ellos tiene implicaciones basadas en su firma? Por ejemplo, ¿usaría el constructor para transmitir que el B está reteniendo una referencia al A pasado? Estas son las clases de consideraciones en las que estoy pensando.

Gracias!

Answer 1

Todas las opciones que menciona son válidas. Cuál elegirías dependería de las circunstancias particulares.

//constructor? 
public B(A a) 
{ 
    //set b's properties from a 
} 

El patrón constructor sería la opción cuando B no puede existir sin los datos de A.

//factory method? 
public static B FromA(A a) 
{ 
    B b = new B(); 
    //set b's properties from a 
    return b; 
} 

El método de fábrica sería el patrón de elección cuando los valores B consigue dependen de los valores de A o B. Especialmente si B tiene descendientes que un valor en A proporcionaría una opción de construcción.

//setter method? 
public static void SetBFromA(B b, A a) 
{ 
    //set b's properties from a 
} 

El método de selección no sería aplicable en su escenario ya que esto sería utilizado cuando A y B no saben el uno del otro y un tercero tiene que interceder.

//assignment method? 
public void AssignFrom(A a) 
{ 
    //set b's properties from a 
} 

Esto es esencialmente un patrón de visitante. A visita B y deja algo de sí mismo (piensa en días de soltero). Este sería el patrón de elección si los datos de A son opcionales para B.

Answer 2

Usaría el método constructor o la conversión explícita.

public static explicit operator B(A typ) 
{ 

} 

En general, creo que esto es muy subjetivo. Todos podemos publicar una respuesta con el método diferente y ver cuál es el que recibe más votos, pero realmente cada forma tiene diferentes beneficios y deficiencias. Dependería más del contexto y de cómo se realiza este patrón en el resto del código.

Answer 3

No creo que haya una práctica común como tal. Cuando hice esto, utilicé el método de fábrica o de constructor. Probablemente preferiría la fábrica.

Answer 4

Voy a tirar una alternativa:

public static B CreateFromA(A a) { } 

Este utiliza una sintaxis de la fábrica, para sugerir que se puede poner hacia fuera un B dado una A, pero evitando cualquier cosa que se parece a una conversión.