Campos (Guía de programación de C#)

Un campo es una variable de cualquier tipo que se declara directamente en una clase o struct. Los campos son miembros de su tipo contenedor.

Una clase o struct puede tener campos de instancia, campos estáticos o ambos. Los campos de instancia son específicos de una instancia de un tipo. Si tiene una clase T, con un campo de instancia F, puede crear dos objetos de tipo T y modificar el valor de F en cada objeto sin afectar el valor del otro objeto. Por el contrario, un campo estático pertenece al propio tipo y se comparte entre todas las instancias de ese tipo. Solo puede acceder al campo estático mediante el nombre del tipo. Si obtiene acceso al campo estático mediante un nombre de instancia, obtendrá el error en tiempo de compilación CS0176.

Por lo general, solo se deben usar campos para las variables que tienen accesibilidad privada o protegida. Los datos que el tipo expone al código de cliente se deben proporcionar mediante métodos, propiedades e indizadores. Mediante estas construcciones para el acceso indirecto a los campos internos, se puede proteger de los valores de entrada no válidos. Un campo privado que almacena los datos expuestos por una propiedad pública se denomina memoria auxiliar o campo de respaldo.

Los campos almacenan habitualmente los datos que deben ser accesibles para más de un método de tipo y que deben almacenarse durante más tiempo de lo que dura un único método. Por ejemplo, es posible que un tipo que representa una fecha de calendario tenga tres campos enteros: uno para el mes, otro para el día y otro para el año. Las variables que no se usan fuera del ámbito de un único método se deben declarar como variables locales dentro del campo del método.

Los campos se declaran en el bloque de clase o estructura mediante la especificación del nivel de acceso del campo, seguido por el tipo del campo, seguido por el nombre del campo. Por ejemplo:

public class CalendarEntry
{

    // private field (Located near wrapping "Date" property).
    private DateTime _date;

    // Public property exposes _date field safely.
    public DateTime Date
    {
        get
        {
            return _date;
        }
        set
        {
            // Set some reasonable boundaries for likely birth dates.
            if (value.Year > 1900 && value.Year <= DateTime.Today.Year)
            {
                _date = value;
            }
            else
            {
                throw new ArgumentOutOfRangeException("Date");
            }
        }
    }

    // public field (Generally not recommended).
    public string? Day;

    // Public method also exposes _date field safely.
    // Example call: birthday.SetDate("1975, 6, 30");
    public void SetDate(string dateString)
    {
        DateTime dt = Convert.ToDateTime(dateString);

        // Set some reasonable boundaries for likely birth dates.
        if (dt.Year > 1900 && dt.Year <= DateTime.Today.Year)
        {
            _date = dt;
        }
        else
        {
            throw new ArgumentOutOfRangeException("dateString");
        }
    }

    public TimeSpan GetTimeSpan(string dateString)
    {
        DateTime dt = Convert.ToDateTime(dateString);

        if (dt.Ticks < _date.Ticks)
        {
            return _date - dt;
        }
        else
        {
            throw new ArgumentOutOfRangeException("dateString");
        }
    }
}

Para acceder a un campo en una instancia, agregue un punto después del nombre de instancia, seguido del nombre del campo, como en instancename._fieldName. Por ejemplo:

CalendarEntry birthday = new CalendarEntry();
birthday.Day = "Saturday";

Se puede proporcionar un valor inicial a un campo mediante el operador de asignación cuando se declara el campo. Para asignar automáticamente el campo Day a "Monday", por ejemplo, se declararía Day como en el ejemplo siguiente:

public class CalendarDateWithInitialization
{
    public string Day = "Monday";
    //...
}

Los campos se inicializan inmediatamente antes de que se llame al constructor para la instancia del objeto. Si el constructor asigna el valor de un campo, sobrescribirá cualquier valor dado durante la declaración del campo. Para obtener más información, vea Utilizar constructores.

Nota:

Un inicializador de campo no puede hacer referencia a otros campos de instancia.

Se pueden marcar campos como público, privado, protegido, interno, protegido interno o privado protegido. Estos modificadores de acceso definen cómo los usuarios del tipo pueden acceder a los campos. Para obtener más información, consulte Modificadores de acceso.

Opcionalmente, un campo se puede declarar como static. El campo estático está disponible para los autores de la llamada en cualquier momento, aunque no exista ninguna instancia del tipo. Para más información, vea Clases estáticas y sus miembros.

Se puede declarar un campo como readonly. Solamente se puede asignar un valor a un campo de solo lectura durante la inicialización o en un constructor. Un campo static readonly es similar a una constante, salvo que el compilador de C# no tiene acceso al valor de un campo estático de solo lectura en tiempo de compilación, solo en tiempo de ejecución. Para obtener más información, vea Constants (Constantes).

Se puede declarar un campo como obligatorio. Un campo obligatorio lo debe inicializar el constructor o un inicializador de objetos cuando se crea un objeto. Agregue el atributo System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute a cualquier declaración de constructor que inicialice todos los miembros necesarios.

El modificador required no se puede combinar con el modificador readonly en el mismo campo.

Especificación del lenguaje C#

Para obtener más información, consulte la Especificación del lenguaje C#. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.

Vea también