ЗаписиRecords

Записи представляют собой простые агрегаты именованных значений, которые могут иметь элементы.Records represent simple aggregates of named values, optionally with members. Они могут быть либо структурами, либо ссылочными типами.They can either be structs or reference types. По умолчанию они являются ссылочными типами.They are reference types by default.

СинтаксисSyntax

[ attributes ]
type [accessibility-modifier] typename =
    { [ mutable ] label1 : type1;
      [ mutable ] label2 : type2;
      ... }
    [ member-list ]

RemarksRemarks

В предыдущем синтаксисе TypeName — это имя типа записи, Label1 и ярлык2 — имена значений, называемые метками, а Type1 и тип2 — типы этих значений.In the previous syntax, typename is the name of the record type, label1 and label2 are names of values, referred to as labels, and type1 and type2 are the types of these values. member-list — это необязательный список элементов для типа.member-list is the optional list of members for the type. Атрибут можно использовать [<Struct>] для создания записи структуры, а не для записи, которая является ссылочным типом.You can use the [<Struct>] attribute to create a struct record rather than a record which is a reference type.

Ниже приводятся некоторые примеры.Following are some examples.

// Labels are separated by semicolons when defined on the same line.
type Point = { X: float; Y: float; Z: float; }

// You can define labels on their own line with or without a semicolon.
type Customer = 
    { First: string
      Last: string;
      SSN: uint32
      AccountNumber: uint32; }

// A struct record.
[<Struct>]
type StructPoint = 
    { X: float
      Y: float
      Z: float }

Если каждая метка находится в отдельной строке, точка с запятой является необязательной.When each label is on a separate line, the semicolon is optional.

Значения можно задавать в выражениях, называемых выражениями записи.You can set values in expressions known as record expressions. Компилятор выводит тип из используемых меток (если метки достаточно отличаются от других типов записей).The compiler infers the type from the labels used (if the labels are sufficiently distinct from those of other record types). Фигурные скобки ({}) заключают выражение записи.Braces ({ }) enclose the record expression. В следующем коде показано выражение записи, которое инициализирует запись с тремя элементами с плавающей запятой с метками x y и z .The following code shows a record expression that initializes a record with three float elements with labels x, y and z.

let mypoint = { X = 1.0; Y = 1.0; Z = -1.0; }

Не используйте сокращенную форму, если возможно наличие другого типа, который также имеет одинаковые метки.Do not use the shortened form if there could be another type that also has the same labels.

type Point = { X: float; Y: float; Z: float; }
type Point3D = { X: float; Y: float; Z: float }
// Ambiguity: Point or Point3D?
let mypoint3D = { X = 1.0; Y = 1.0; Z = 0.0; }

Метки последнего объявленного типа имеют приоритет над элементами ранее объявленного типа, поэтому в предыдущем примере mypoint3D выводится как Point3D .The labels of the most recently declared type take precedence over those of the previously declared type, so in the preceding example, mypoint3D is inferred to be Point3D. Можно явно указать тип записи, как показано в следующем коде.You can explicitly specify the record type, as in the following code.

let myPoint1 = { Point.X = 1.0; Y = 1.0; Z = 0.0; }

Методы могут быть определены для типов записей так же, как для типов классов.Methods can be defined for record types just as for class types.

Создание записей с помощью выражений записиCreating Records by Using Record Expressions

Можно инициализировать записи с помощью меток, определенных в записи.You can initialize records by using the labels that are defined in the record. Выражение, которое делает это, называется выражением записи.An expression that does this is referred to as a record expression. Используйте фигурные скобки, чтобы заключить выражение записи и использовать точку с запятой в качестве разделителя.Use braces to enclose the record expression and use the semicolon as a delimiter.

В следующем примере показано, как создать запись.The following example shows how to create a record.

type MyRecord = 
    { X: int
      Y: int
      Z: int }

let myRecord1 = { X = 1; Y = 2; Z = 3; }

Точки с запятой после последнего поля в выражении записи и в определении типа являются необязательными независимо от того, все ли поля находятся в одной строке.The semicolons after the last field in the record expression and in the type definition are optional, regardless of whether the fields are all in one line.

При создании записи необходимо указать значения для каждого поля.When you create a record, you must supply values for each field. Нельзя ссылаться на значения других полей в выражении инициализации для любого поля.You cannot refer to the values of other fields in the initialization expression for any field.

В следующем коде тип myRecord2 выводится из имен полей.In the following code, the type of myRecord2 is inferred from the names of the fields. При необходимости можно явно указать имя типа.Optionally, you can specify the type name explicitly.

let myRecord2 = { MyRecord.X = 1; MyRecord.Y = 2; MyRecord.Z = 3 }

Другая форма создания записи может быть полезной, если необходимо скопировать существующую запись и, возможно, изменить некоторые значения полей.Another form of record construction can be useful when you have to copy an existing record, and possibly change some of the field values. Это показано в следующей строке кода.The following line of code illustrates this.

let myRecord3 = { myRecord2 with Y = 100; Z = 2 }

Эта форма выражения записи называется выражением копирования и обновления записи.This form of the record expression is called the copy and update record expression.

По умолчанию записи являются неизменяемыми; Однако вы можете легко создавать измененные записи с помощью выражения копирования и обновления.Records are immutable by default; however, you can easily create modified records by using a copy and update expression. Можно также явно указать изменяемое поле.You can also explicitly specify a mutable field.

type Car = 
    { Make : string
      Model : string
      mutable Odometer : int }

let myCar = { Make = "Fabrikam"; Model = "Coupe"; Odometer = 108112 }
myCar.Odometer <- myCar.Odometer + 21

Не используйте атрибут DefaultValue с полями записей.Don't use the DefaultValue attribute with record fields. Лучшим подходом является определение экземпляров по умолчанию для записей с полями, которые инициализируются значениями по умолчанию, а затем использование выражения копирования и обновления записей для установки любых полей, которые отличаются от значений по умолчанию.A better approach is to define default instances of records with fields that are initialized to default values and then use a copy and update record expression to set any fields that differ from the default values.

// Rather than use [<DefaultValue>], define a default record.
type MyRecord =
    { Field1 : int
      Field2 : int }

let defaultRecord1 = { Field1 = 0; Field2 = 0 }
let defaultRecord2 = { Field1 = 1; Field2 = 25 }

// Use the with keyword to populate only a few chosen fields
// and leave the rest with default values.
let rr3 = { defaultRecord1 with Field2 = 42 }

Создание взаимно рекурсивных записейCreating Mutually Recursive Records

Иногда при создании записи может потребоваться, чтобы она зависела от другого типа, который вы хотите определить позже.Sometime when creating a record, you may want to have it depend on another type that you would like to define afterwards. Это ошибка компиляции, если не определить типы записей для взаимной рекурсивной рекурсии.This is a compile error unless you define the record types to be mutually recursive.

Определение взаимно рекурсивных записей выполняется с помощью and ключевого слова.Defining mutually recursive records is done with the and keyword. Это позволяет связать 2 или более типов записей вместе.This lets you link 2 or more record types together.

Например, следующий код определяет Person Address тип и как взаимно рекурсивный:For example, the following code defines a Person and Address type as mutually recursive:

// Create a Person type and use the Address type that is not defined
type Person =
  { Name: string
    Age: int
    Address: Address }
// Define the Address type which is used in the Person record
and Address =
  { Line1: string
    Line2: string
    PostCode: string
    Occupant: Person }

Если бы вы определили предыдущий пример без and ключевого слова, он не будет компилироваться.If you were to define the previous example without the and keyword, then it would not compile. andДля взаимно рекурсивных определений требуется ключевое слово.The and keyword is required for mutually recursive definitions.

Сопоставление шаблонов с записямиPattern Matching with Records

Записи можно использовать с сопоставлением шаблонов.Records can be used with pattern matching. Можно явно указать некоторые поля и предоставить переменные для других полей, которые будут назначаться при совпадении.You can specify some fields explicitly and provide variables for other fields that will be assigned when a match occurs. Это показано в следующем примере кода.The following code example illustrates this.

type Point3D = { X: float; Y: float; Z: float }
let evaluatePoint (point: Point3D) =
    match point with
    | { X = 0.0; Y = 0.0; Z = 0.0 } -> printfn "Point is at the origin."
    | { X = xVal; Y = 0.0; Z = 0.0 } -> printfn "Point is on the x-axis. Value is %f." xVal
    | { X = 0.0; Y = yVal; Z = 0.0 } -> printfn "Point is on the y-axis. Value is %f." yVal
    | { X = 0.0; Y = 0.0; Z = zVal } -> printfn "Point is on the z-axis. Value is %f." zVal
    | { X = xVal; Y = yVal; Z = zVal } -> printfn "Point is at (%f, %f, %f)." xVal yVal zVal

evaluatePoint { X = 0.0; Y = 0.0; Z = 0.0 }
evaluatePoint { X = 100.0; Y = 0.0; Z = 0.0 }
evaluatePoint { X = 10.0; Y = 0.0; Z = -1.0 }

Выходные данные этого кода выглядят следующим образом.The output of this code is as follows.

Point is at the origin.
Point is on the x-axis. Value is 100.000000.
Point is at (10.000000, 0.000000, -1.000000).

Записи и членыRecords and members

Вы можете указать элементы в записях так же, как и с классами.You can specify members on records much like you can with classes. Поля не поддерживаются.There is no support for fields. Распространенный подход заключается в определении Default статического члена для простоты создания записей:A common approach is to define a Default static member for easy record construction:

type Person =
  { Name: string
    Age: int
    Address: string }

    static member Default =
        { Name = "Phillip"
          Age = 12
          Address = "123 happy fun street" }

let defaultPerson = Person.Default

При использовании собственного идентификатора этот идентификатор ссылается на экземпляр записи, членом которой является:If you use a self identifier, that identifier refers to the instance of the record whose member is called:

type Person =
  { Name: string
    Age: int
    Address: string }

    member this.WeirdToString() =
        this.Name + this.Address + string this.Age

let p = { Name = "a"; Age = 12; Address = "abc123" }
let weirdString = p.WeirdToString()

Различия между записями и классамиDifferences Between Records and Classes

Поля записей отличаются от полей классов тем, что они автоматически предоставляются как свойства и используются при создании и копировании записей.Record fields differ from class fields in that they are automatically exposed as properties, and they are used in the creation and copying of records. Построение записей также отличается от создания класса.Record construction also differs from class construction. В типе записи нельзя определить конструктор.In a record type, you cannot define a constructor. Вместо этого применяется синтаксис создания, описанный в этом разделе.Instead, the construction syntax described in this topic applies. Классы не имеют прямой связи между параметрами конструктора, полями и свойствами.Classes have no direct relationship between constructor parameters, fields, and properties.

Как и типы Union и Structure, записи имеют семантику структурного равенства.Like union and structure types, records have structural equality semantics. Классы имеют семантику равенства ссылок.Classes have reference equality semantics. Это действие представлено в следующем примере кода:The following code example demonstrates this.

type RecordTest = { X: int; Y: int }

let record1 = { X = 1; Y = 2 }
let record2 = { X = 1; Y = 2 }

if (record1 = record2) then
    printfn "The records are equal."
else
    printfn "The records are unequal."

Результат выполнения этого кода выглядит следующим образом:The output of this code is as follows:

The records are equal.

Если написать тот же код с классами, то два объекта класса будут неравными, так как два значения будут представлять два объекта в куче и будут сравниваться только адреса (если только тип класса не переопределит System.Object.Equals метод).If you write the same code with classes, the two class objects would be unequal because the two values would represent two objects on the heap and only the addresses would be compared (unless the class type overrides the System.Object.Equals method).

Если для записей требуется равенство ссылок, добавьте атрибут [<ReferenceEquality>] над записью.If you need reference equality for records, add the attribute [<ReferenceEquality>] above the record.

См. также разделSee also