Capacitación detallada de la API de Terraria del equipo de StarLife

Algunos de los modificadores más populares son los modificadores de acceso, que son responsables del nivel de seguridad de su método o variable.
Hay 4 modificadores de acceso en total:

1) -public es un modificador público que le permite usar una clase, método o variable en otros archivos o métodos:
public static int hungerscore = 350; // variable pública que se puede utilizar en otros métodos.
Hunger.Hunger.hungerscore + = 15; // para que podamos usar hungerscore en otros archivos.

2) -protected es un modificador protegido que prohíbe el uso de una clase, método o variable en otros archivos.
protegido estático int hungerscore = 350; // protege nuestra variable
Hunger.Hunger.hungerscore + = 15; //error

3) -private es un modificador privado que le otorga el permiso mínimo para usar una clase, método o variable.
Empleado público vacío (); //método
{
privado int i; // la variable solo se puede usar en este método
}

4) -internal es un modificador que se usa solo para tipos y miembros de tipos.
Base de vacío público ()
{
interno estático int x = 0; // el tipo o miembro interno solo está disponible dentro de archivos en el mismo ensamblaje
}

-const es un modificador constante que indica que el valor de una variable no se puede cambiar usando este modificador.
-event - un modificador que declara un evento (no invasiones)
-extern es un modificador que indica que el método tiene una implementación
-override: un modificador que proporciona una implementación de miembro virtual
-unsafe es un modificador que declara un contexto inseguro
-virtual: un modificador que declara un método o descriptor de acceso, cuya implementación se puede cambiar
-new - modificador que oculta el miembro heredado de la clase base
-sealed - modificador que indica que la clase no se puede heredar
-static: un modificador que se usa para declarar un miembro estático que pertenece al tipo en sí, y no a un objeto específico

Además de estos modificadores, también hay de solo lectura, volátiles, abstractos, asíncronos, que se utilizan con menos frecuencia que otros.
// La implementación es el resultado.
// // - un comentario.

Usado para declarar variables con un valor muy pequeño, así es como se declaran las variables:

sbyte VariableName;
VariableName = valor;

byte - de 0 a 255

Tipo de variable con un rango de cero a 255, ejemplo:

Nombre de byte;
Nombre = 25;

char - de U + 0000 a U + ffff

No utilizado

bool - verdadero o falso

Se utiliza con mayor frecuencia para indicar la veracidad de un valor, por ejemplo:

bool Nombre;
Nombre = falso;

Aquí, he declarado la variable Nombre con tipo bool como falsa. Este tipo a menudo se compara con el código binario.

corto - de -32768 a 32767

Tipo de variable con también un rango pequeño, ejemplo:

nombre corto;
Nombre = 40;

ushort - de 0 a 65535

Tipo de variable similar a corto, pero con un rango de cero a 65535, ejemplo:

Nombre corto;
Nombre = 0;

float - números con porcentajes (± 1,5 * 10-45 a ± 3,4 * 1033)

Valor porcentual, generalmente utilizado así:

nombre flotante;
flotanteNombre2;
flotanteNombre3;

Nombre = 6f;
Nombre2 = 7f;
Nombre3 = 8f;

Nombre * = 0.9f;

Multiplica el valor de la variable Nombre por 0.9℅

Nombre2 + = 4f;

Agregar 4℅ a Name2

Nombre 3 - = 7f;

Resta 7℅ del valor de la variable Name3

También debe escribir siempre f al declarar un valor de variable de tipo float, de lo contrario generará un error de conversión incorrecta al tipo double.

ulong - de 0 a 18446744073709551615

Este es el mismo tipo largo, pero con un rango de cero a 18446744073709551615, por lo general, valores tan grandes no se usan correctamente, pero se pueden usar, por ejemplo, para daños frenéticos, por ejemplo:

Daño ulong;
Daño = 18446744073709551615;

largo - desde -9223372036854775808 hasta 9223372036854775807

Este tipo es necesario si desea declarar una variable con un valor muy grande, por ejemplo 10 mil millones de daño, se declara de la misma manera que otros tipos de números de variable.

nombre largo;
Nombre = 10000000000;

uint - 0 a 4294967295

Este tipo es necesario para declarar variables con un valor de 0 o números positivos hasta 4294967295, por ejemplo:

uint Nombre;
Nombre = 0;
uintNombre2;
Nombre2 = 40;

int - de -2147483648 a 2147483647

El tipo más común de números de variable, ejemplo:

int Nombre;
Nombre = -150;

O

int Nombre;
Nombre = 150;

También puede usar matemáticas en declaraciones de variables usando los signos + - * /, ejemplo:

entonar;
int Dos;
int Tres;

Uno = 1;
Dos = 2;
Tres = Uno + Dos;

Además, esto solo se aplica a variables del mismo tipo, lo cual es lógico.

Estos nombres de variables se usaron solo por conveniencia, puede usar sus propios nombres, pero solo en inglés y sin espacios.