c# - publicas - que es private en programacion

Convención de nomenclatura de métodos privados

Question

¿Existe una convención para nombrar el método privado que he llamado " _Add " aquí? No soy fanático del guion bajo pero es lo que sugiere uno de mis compañeros de equipo.

public Vector Add(Vector vector) {
    // check vector for null, and compare Length to vector.Length
    return _Add(vector);
}

public static Vector Add(Vector vector1, Vector vector2) {
    // check parameters for null, and compare Lengths
    Vector returnVector = vector1.Clone()
    return returnVector._Add(vector2);
}

private Vector _Add(Vector vector) {
    for (int index = 0; index < Length; index++) {
        this[index] += vector[index];
    }
    return this;
}

Answer 1

Creo que con la mayoría de las convenciones hay más libertad en lo privado. Sin embargo, veo esto mucho:

private Vector AddCore(Vector vector)

o

private Vector DoAdd(Vector vector)

Sin embargo, probablemente dejaré caer el método privado y solo tendré uno:

public static Vector Add(Vector vector1, Vector vector2) 
{
    // check if vector1 is null
    Vector returnVector = vector1.Clone()
    return returnVector.Add(vector2);
}

public Vector Add(Vector vector) 
{
    // check parameters for null, and compare Lengths
    for (int index = 0; index < Length; index++) {
        this[index] += vector[index];
    }
    return this;
}

Pon también esas llaves en el lugar correcto :-)

Answer 2

Desafortunadamente, me he encontrado con esta convención, junto con una tendencia a nombrar controles en un formulario con un guión bajo (por ejemplo, "_txtFirstname" en lugar de solo "txtFirstname"). Parece ser un extraño efecto bleedover de la práctica ya no recomendada por MS de nombrar variables privadas con un guion bajo. Eso, o los programadores simplemente adoran usar la tecla de guión bajo sin motivo alguno que pueda descifrar.

No use esta convención, y cuando su compañero de trabajo lo insista, pídale que busque algo ( cualquier cosa ) en línea que recomiende esta práctica.

Answer 3

Es bastante común usar un guión bajo para las propiedades privadas, pero nunca lo he visto en los métodos

Answer 4

Me gustaría lo que mis compañeros de equipo sugirieran y convertirlo en una convención en el equipo. Pero en el caso particular, parece que podrías evitarlo:

public Vector Add(Vector vector) {
    // check vector for null, and compare Length to vector.Length
    for (int index = 0; index < Length; index++) {
        this[index] += vector[index];
    }
    return this;
}

public static Vector Add(Vector vector1, Vector vector2) {
    // check parameters for null, and compare Lengths
    Vector returnVector = vector1.Clone()
    return returnVector.Add(vector2);
}

O tal vez no debería estar en TAN tan tarde ...

Answer 5

Normalmente veo y uso "AddCore" o "InnerAdd"

Answer 6

Sea descriptivo con los nombres de los métodos para crear un código que se explique a sí mismo, no debería haber colisiones porque no debería tener dos métodos haciendo exactamente lo mismo, por lo que no debería tener ninguna razón para necesitar un carácter para prefijar los nombres de los métodos.

Algunas personas prefijan campos privados con "m_", no he visto ningún estilo similar para métodos privados.

Answer 7

Usualmente uso thisCase para métodos privados y ThatCase para métodos públicos.

private Vector add(Vector vector) {
    for (int index = 0; index < Length; index++) {
        this[index] += vector[index];
    }
    return this;
}

public Vector Add(Vector vector) {
    for (int index = 0; index < Length; index++) {
        this[index] += vector[index];
    }
    return this;
}

Answer 8

Dado que el público Add () hace algunos controles y el privado no:

private Vector AddUnchecked(Vector vector) {
    for (int index = 0; index < Length; index++) {
        this[index] += vector[index];
    }
    return this;
}

Answer 9

Oh, olvidé mencionar por qué hago esto. Es porque es una forma sencilla de crear procesamiento utilizando un bucle para los métodos que me gustaría llamar en secuencia. Por ejemplo, si tengo alguna validación que necesita hacerse ligeramente diferente cada vez pero usando métodos con la misma clase. Los configuré como

add_process = array(1,2,3);
delete_process = array(2,6,4);

//delete user, users  posts and users comments
foreach( process2 as value){
 method_{value}_delete
} 

Answer 10

Las dos variaciones que he visto comúnmente usadas son estas:

private Vector DoAdd(Vector vector) { ... }

y

private Vector AddImpl(Vector vector) { ... }

Ninguno de los dos es particularmente satisfactorio, pero es lo que he visto.

Nunca he visto una convención de que TODOS los métodos privados tengan un prefijo, ¡el mero pensamiento me hace estremecer!

Ya es bastante malo lidiar con todos los desarrolladores de C ++ que prefijan a cada miembro a la vista con "_", y estoy hablando como un antiguo desarrollador de Delphi que solía marcar como prefijo a cada miembro con "F". ¡Aún me estoy recuperando de eso!

Answer 11

Métodos públicos:

public void Add()
{
}
this.Add()

Métodos privados:

private void _Add()
{
}
_Add();

Propiedades:

public int Id {get;set;}
this.Id = 10;

Campos:

private bool _isUsed;
_isUsed = false;

Variables locales:

bool isUsed;

Answer 12

EPiServer usa una convención de "... Interno" como en AddInternal() en esta situación.

Answer 13

Personalmente, para los métodos, tengo la misma convención de nomenclatura independientemente de la visibilidad.

Estas son mis convenciones de nombres para C #:

• Espacios de nombres, tipos, métodos, propiedades: PascalCase
• Variables locales: camelCase
• Parámetros de métodos: camelCase
• Campos privados: _PascalCase con prefijo de guión bajo, si el campo de respaldo para la propiedad, luego el mismo nombre que la propiedad solo con el prefijo de subrayado

Editar : Nota, soy culpable de usar nombres de prefijos para métodos privados. No capté esa parte particular de tu pregunta la primera vez que la leí.

Por ejemplo, si tengo 7 maneras diferentes de ejecutar mi instrucción SQL a través de mi clase DatabaseCommand, como QueryDataTable, QueryEnumerable, QueryEnumerable<T> , QueryDataReader, etc., entonces todas estas quieren llamar a los mismos métodos privados, tengo una tendencia a llama a este método InternalQuery o PrivateQuery.

Answer 14

Nunca he visto ninguna convención de codificación en C # que distinga entre métodos públicos y privados. No sugiero hacerlo, ya que no veo el beneficio.

Si el nombre del método entra en conflicto con los métodos públicos, es hora de ser más descriptivo; si, como en su caso, contiene la implementación del método real para el método público, una convención es llamarlo *Impl . Es decir AddImpl en su caso.