example - ¿Cuál es el equivalente de C#de un amigo?

params comments c#

Question

Posible duplicado:
¿Por qué C # no proporciona la palabra clave ''amigo'' de estilo C ++?

Me gustaría que las variables miembro privado de una clase sean accesibles para una clase Tester sin exponerlas a otras clases.

En C ++ solo declararía la clase Tester como un amigo, ¿cómo hago esto en C #? ¿Puede alguien darme un ejemplo?

Answer 1

El equivalente de armario es crear una clase anidada que podrá acceder a los miembros privados de la clase externa. Algo como esto:

class Outer
{
    class Inner
    {
       // This class can access Outer''s private members
    }
}

o si prefiere poner la clase interna en otro archivo:

Outer.cs
partial class Outer
{
}


Inner.cs
partial class Outer
{
    class Inner
    {
       // This class can access Outer''s private members
    }
}

Answer 2

No hay un equivalente directo de "amigo": lo más cercano que está disponible (y no está muy cerca) es InternalsVisibleTo . Solo he usado este atributo para probar, ¡donde es muy útil!

Ejemplo: Para colocarse en AssemblyInfo.cs

[assembly: InternalsVisibleTo("OtherAssembly")]

Answer 3

No hay una palabra clave ''friend'' en C #, pero una opción para probar métodos privados es utilizar System.Reflection para obtener un control del método. Esto le permitirá invocar métodos privados.

Dada una clase con esta definición:

public class Class1
{
    private int CallMe()
    {
        return 1;
    }
}

Puedes invocarlo usando este código:

Class1 c = new Class1();
Type class1Type = c.GetType();
MethodInfo callMeMethod = class1Type.GetMethod("CallMe", BindingFlags.Instance | BindingFlags.NonPublic);

int result = (int)callMeMethod.Invoke(c, null);

Console.WriteLine(result);

Si está utilizando Visual Studio Team System, puede hacer que VS genere automáticamente una clase proxy con accesadores privados haciendo clic derecho en el método y seleccionando "Crear pruebas unitarias ..."

Answer 4

Puede simular el acceso de un amigo si la clase a la que se le otorga el derecho de acceso está dentro de otro paquete y si los métodos que está exponiendo están marcados como protegidos internos o internos. Debe modificar el conjunto que desea compartir y agregar la siguiente configuración a AssemblyInfo.cs:

// Expose the internal members to the types in the My.Tester assembly
[assembly: InternalsVisibleTo("My.Tester, PublicKey=" +
"012700000480000094000000060200000024000052534131000400000100010091ab9" +
"ba23e07d4fb7404041ec4d81193cfa9d661e0e24bd2c03182e0e7fc75b265a092a3f8" +
"52c672895e55b95611684ea090e787497b0d11b902b1eccd9bc9ea3c9a56740ecda8e" +
"961c93c3960136eefcdf106955a4eb8fff2a97f66049cd0228854b24709c0c945b499" +
"413d29a2801a39d4c4c30bab653ebc8bf604f5840c88")]

La clave pública es opcional, según sus necesidades.

Answer 5

Toma un patrón muy común. Class Factory hace Widgets. La clase de fábrica necesita rebuscar con las partes internas, porque es la fábrica. Ambos se implementan en el mismo archivo y son, por diseño, deseo y naturaleza, clases estrechamente conectadas; de hecho, Widget es realmente solo un tipo de salida de fábrica.

En C ++, haz de Factory un amigo de la clase de Widget.

En C #, ¿qué podemos hacer? La única solución decente que se me ha ocurrido es inventar una interfaz, IWidget, que solo expone los métodos públicos, y tiene las interfaces de devolución de fábrica de IWidget.

Esto implica una buena dosis de tedio, exponiendo de nuevo todas las propiedades públicas de forma natural en la interfaz.