Театр начинается с гардеробной, а классы с конструкторов. Конструктор должен выполнить определенный программный код и подготовить объект класса к использованию. Классы языка программирования F# имеют в своём составе различные виды конструкторов, из которых один, называемый первичным, является обязательным. Все дополнительные конструкторы строго должны вызывать первичный конструктор.
// Определение класса
type [access-modifier] type-name [type-params] [access-modifier] ( parameter-list ) [ as identifier ] =
[ class ]
[ inherit base-type-name(base-constructor-args) ]
// --- Код первичного конструктора ---
[ let-bindings ]
[ do-bindings ]
// --- /Код первичного конструктора ---
member-list
...
end
Первичный конструктор класса F# состоит из входных параметров и комплексного программного кода. Код конструктора образуют let и/или do привязки. Данные привязки определяются в начале класса и исполняются в порядке их объявления. Количество let и do привязок может быть любым. Локальные поля, образуемые привязками доступны во всём определении класса, но не доступны из статических методов и свойств. Статические члены класса могут получать доступ только к полям, объявленным как статические.
Параметры конструктора объявляются внутри круглых скобок. Конструктор без параметров обозначается двумя пустыми круглыми скобками. Код первичного конструктора находится вначале кода класса, сразу после определения родительских классов. После кода первичного компьютера определяются члены класса: дополнительные конструкторы, методы, свойства. В отличие от других языков .NET классы F# имеют составной первичный конструктор, из параметров, кода формирования полей из let-привязок и исполняющего кода do-привязок.
Пример кода первичного конструктора без параметров. Тело первичного конструктора состоит только из одной let-привязки - функции построения таблицы умножения.
// Таблица умножения
type MultiplicationTable() =
class
// --- Код первичного конструктора ---
let res =
for n = 1 to 9 do
for m = 1 to 9 do
printf "%dx%d=%d " m n (m*n)
// Переход на следующую строку.
printfn""
// Пустая строка после таблицы умножения.
printfn""
// --- /Код первичного конструктора ---
// Открытый метод класса после кода первичного конструктора.
member this.Exponentiation x y = x ** y
end
// Код запуска консольного приложения.
[<EntryPoint>]
let main argv =
// Создание экземпляра класса.
let pc = MultiplicationTable()
0 // return an integer exit code
Вывод в консоль исполнение кода первичного конструктора экземпляра класса MultiplicationTable:
Пример кода первичного конструктора с параметрами num, maxmultiplier. Первичный конструктор включает код нескольких let и do привязок. Обратите внимание на использование статических полей в членах класса.
// Умножение данного числа на данный диапазон чисел
type MultiplicationRange(num: int, maxmultiplier: int) as self =
// -- Статический конструктор ---
static let mutable staticlet = 230
// -- /Статический конструктор ---
// --- Код первичного конструктора ---
let check =
if maxmultiplier > 100
then 100
else maxmultiplier
do
for m = 1 to check do
printfn $"%d{num}x%d{m}=%d{(m*num)}"
do
self.Message
self.ViewStaticLet
// --- /Код первичного конструктора ---
member this.Message =
printfn "Максимальный множитель = %d" check
// Использование статического поля в методе экземпляра
member this.ViewStaticLet =
printfn "Значение статического поля staticlet= %d" staticlet
static member StaticProperty
with get () = staticlet
and set (value) = staticlet <- value
static member StaticFunction = 45 + staticlet
[<EntryPoint>]
let main argv =
let pc = MultiplicationRange(9,10)
0 // return an integer exit code
Вывод в консоль после создания экземпляра класса MultiplicationRange:
9x1=9
9x2=18
9x3=27
9x4=36
9x5=45
9x6=54
9x7=63
9x8=72
9x9=81
9x10=90
Максимальный множитель = 10
Значение статического поля staticlet= 230
Для повышения универсальности при применении объектов, в классах F# можно создавать вторичные или дополнительные конструкторы. Вторичные конструкторы "внешне" не отличаются от первичных, т. е. могут быть с параметрами и без параметров. Необходимым условием создания дополнительного конструктора это вызов первичного конструктора вначале программного кода дополнительного конструктора.
Программный код самого дополнительного конструктора определяется после ключевого слова then, следующего за вызовом основного конструктора. Доступ к членам класса из кода вторичного конструктора можно получить только с помощью идентификатора именно для этого дополнительного конструктора.
Пример кода дополнительных конструкторов
type AddConstructor(p1: int, p2: int) as this =
// --- Тело первичного конструктора ---
let pc = printfn $"
Я первичный конструктор! Параметры: p1=%d{p1}; p2=%d{p2}"
do
printfn "do-привязка первичного конструктора"
// --- Тело первичного конструктора ---
new(x: int) as this2 =
// let-привязки могут участвовать в формировании кода
let mult1 = 9 * 7
let mult2 = 9 * 8
AddConstructor(mult1, mult2) then
printfn "Я второй конструктор. Параметр: %d" x
// У дополнительных конструкторов нет доступа к параметрам первичного.
// Поскольку параметры первичного формирует дополнительный конструктор.
// xx let letprimaryconstructor = p2 // так нельзя
// Доступ к членам класса только посредством собственного идентификатора
// для дополнительного конструктора.
let d = this2.Member
d |> ignore
new(str: string) =
AddConstructor(3, 4) then
printfn "Я третий конструктор. Параметр: %s" str
new(str: string, i: int) =
AddConstructor(5, 6) then
printfn "Я четвёртый конструктор. Параметры: %s, %d" str i
new() =
AddConstructor(7, 8) then
printfn "Я пятый конструктор. Параметры отсутствуют."
member d.Member = 89
[<EntryPoint>]
let main argv =
let addc = AddConstructor(10, 20)
let addc = AddConstructor(4500)
let addc = AddConstructor("Погода сегодня отличная!")
let addc = AddConstructor("Май", 20)
let addc = AddConstructor()
0 // return an integer exit code
Вывод в консоль после запуска приложения. Код основного, первичного конструктора всегда вызывается перед исполнением кода в дополнительных конструкторах.
Я первичный конструктор! Параметры: p1=10; p2=20
do-привязка первичного конструктора
Я первичный конструктор! Параметры: p1=63; p2=72
do-привязка первичного конструктора
Я второй конструктор. Параметр: 4500
Я первичный конструктор! Параметры: p1=3; p2=4
do-привязка первичного конструктора
Я третий конструктор. Параметр: Погода сегодня отличная!
Я первичный конструктор! Параметры: p1=5; p2=6
do-привязка первичного конструктора
Я четвёртый конструктор. Параметры: Май, 20
Я первичный конструктор! Параметры: p1=7; p2=8
do-привязка первичного конструктора
Я пятый конструктор. Параметры отсутствуют.
В F# не применяется модификатор доступа static к классу. Но можно без ограничений создавать в классе let и do статические привязки и статические члены, добавляя классу полноценную статическую функциональность. По аналогии с первичным конструктором, статический конструктор включает в себя статические let и do привязки.
Статические конструкторы выполняются до создания экземпляров класса. Если класс имеет смешанный состав let, do привязок, то при создании нескольких экземпляров таких классов в первую очередь однократно выполняются статические конструкторы, и только затем локальные конструкторы для каждого экземпляра класса.
Если вызывается хотя бы один статический конструктор одного из классов текущего модуля, то выполнятся все статические конструкторы классов текущего модуля, в том числе и в дочерних модулях. При этом явный вызов всех статических классов не требуется, достаточно вызова любого, даже одного, статического конструктора класса.
module StaticConstructors
type SimpleClass() =
// Привязка статического конструктора
static let staticlet1 = printfn "Статическая let-привязка 1 SimpleClass"
let locallet = printfn "
Локальная let-привязка SimpleClass"
static let staticlet2 = printfn "Статическая let-привязка 2 SimpleClass"
do
printfn "Локальная do-привязка SimpleClass"
// Привязка статического конструктора
static do
printfn "Статическая do-привязка SimpleClass"
static member StaticProperty = printfn "StaticProperty SimpleClass"
type StaticClass() =
// Привязка статического конструктора
static let staticlet =
printfn "Статической let-привязка StaticClass"
type LocalClass() =
let locallet =
printfn "Локальная let-привязка LocalClass"
module AddModule1 =
type SC() =
static let staticlet =
printfn "Статическая let-привязка класса в дочернем модуле AddModule1"
module AddModule2 =
type SC() =
static let staticlet =
printfn "Статической let-привязка класса в дочернем модуле AddModule2"
[<EntryPoint>]
let main argv =
let sc = SimpleClass()
let sc = SimpleClass()
let sc = SimpleClass()
0 // return an integer exit code
Вывод в консоль результата создания экземпляров класса. Наглядно видно, что в первую очередь исполнились статические конструкторы всех классов текущего модуля и только затем были вызваны локальные первичные конструкторы необходимое количество раз. Можно заметить, что исполнились все статические конструкторы классов текущего модуля, даже без использования этих классов.
Язык F# позволяет определять в конструкторах необязательные параметры, значения для которых можно не указывать. Такая возможность упрощает создание экземпляров классов и позволяет создавать объекты даже при неизвестных инициирующих значениях. В конструкторах класса можно смешивать обязательные и необязательные параметры.
При анонимном инициировании необязательных параметров требуется соблюдать порядок их определения. Вы можете расставлять аргументы в произвольном порядке, передавая значения по именам параметров, например: (color="Синий", width=45).
При создании собственных классов с конструкторами в которых определены необязательные параметры, очень желательно назначить параметрам значения по умолчанию. Default-значения помогут избежать возникновения исключений в случаях частичного или полного отсутствия аргументов для необязательных параметров.
type ClassParameter(?name: string, ?price: float) =
// В случае отсутствия аргумента присваивается значение по умолчанию.
let mutable n = defaultArg name "без названия"
let mutable p= defaultArg price 0.0
// Метод вывода информации.
member x.Info =
if p > 0 then
printfn $"Название компонента: %s{n}, стоимость %f{p}"
else
printfn "Компонент отсутствует"
type ClassParameters2(?speed: int, ?weight: int, ?color: string) =
// Другой способ присвоения значения по умолчанию.
let s = if speed.IsSome = false then 0 else speed.Value
let w = defaultArg weight 0
let c = defaultArg color "нет данных"
member x.Info =
let speed = if s = 0 then "нет данных" else s.ToString()
let weight = if w = 0 then "Нет данных" else w.ToString()
printfn "Характеристика автомобиля:"
printfn "Скорость - %s" speed
printfn "Вес - %s" weight
printfn "Цвет - %s" c
[<EntryPoint>]
let main argv =
let op = ClassParameter()
op.Info
printfn ""
let op = ClassParameter("Транзистор BC547C", 5.7)
op.Info
printfn ""
// Результатом будут только значения по умолчанию.
let op = ClassParameters2()
op.Info
printfn ""
// Неименованные аргументы должны указываться в порядке определения параметров.
let op = ClassParameters2(220, 2300, "Красный")
op.Info
printfn ""
// Именованные аргументы можно писать в произвольном порядке
let op = ClassParameters2(color = "Желтый", speed = 245)
op.Info
printfn ""
0 // return an integer exit code
Вывод результатов в консоль:
Компонент отсутствует
Название компонента: Транзистор BC547C, стоимость 5.700000
Характеристика автомобиля:
Скорость - нет данных
Вес - Нет данных
Цвет - нет данных
Характеристика автомобиля:
Скорость - 220
Вес - 2300
Цвет - Красный
Характеристика автомобиля:
Скорость - 245
Вес - Нет данных
Цвет - Желтый
Если класс содержит открытые свойства для чтения и записи, то такие свойства можно инициализировать при создании объекта класса. Внешне это напоминает вызов конструктора с именованными параметрами с тем отличием что значения присваиваются свойствам класса.
F# предоставляет гибкую схему инициализации свойств при создании объекта класса одновременно с параметрами конструктора, как обязательными, так и необязательными.
// Конструктор без параметров.
type PropClass() =
let mutable length = 0
let mutable width = 0
let mutable height = 0
member x.Length
with get() = length
and set(v) = length <- v
member x.Width
with get() = width
and set(v) = width <- v
member x.Height
with get() = height
and set(v) = height <- v
member x.Volume = length * width * height
// Конструктор с одним обязательным параметром.
type PropClassParameter(l: int) =
let mutable length = l
let mutable width = 0
let mutable height = 0
member x.Length
with get() = length
and set(v) = length <- v
member x.Width
with get() = width
and set(v) = width <- v
member x.Height
with get() = height
and set(v) = height <- v
member x.Volume = length * width * height
[<EntryPoint>]
let main argv =
// Инициализация свойств при создании объекта класса
// визуально напоминает конструктор с параметрами.
let pi = PropInit.PropClass(Length = 100, Width = 34, Height = 2)
// Вывод результата вычисления.
printfn $"Объем равен %d{pi.Volume}"
// Инициализация свойств одновременно с обязательным параметром конструктора.
let pi = PropInit.PropClassParameter(100, Width = 34, Height = 2)
printfn $"Объем равен %d{pi.Volume}"
0 // return an integer exit code
Члены-методы классов можно вызывать из кода первичных конструкторов. При этом необходимо руководствоваться несложными правилами: для доступа к методу необходимо создать собственный идентификатор класса, вызов метода осуществлять в do-привязке, после которой нет let-привязок. Т. е. код конструктора, при вызове члена-метода, должен быть уже сформирован и экземпляр класса инициализирован.
Если попытаться вызвать метод в let-привязке или в do-привязке после которой есть let-привязки, то в этом случае возникнет исключение:
System.InvalidOperationException: "The initialization of an object or value resulted in an object or value being accessed recursively before it was fully initialized." ("Инициализация объекта или значения привела к рекурсивному вызову объекта или значения перед его полной инициализацией.")
При вызове метода класса из тела вторичного конструктора обязательные правила: необходимо создать собственный идентификатор для вторичного конструктора, метод вызывать после вызова первичного конструктора.
Программный код вызов метода класса из первичного и вторичного конструктора:
module MethodsCall
type MyClass() as this =
let a = 90
// Код исполнить нельзя, поскольку экземпляр класса еще не создан.
// Выполнение первичного конструктора не закончено.
//let b = this.Method 7 2
let c = 78
// Так можно
do
this.Method 55 48
do
this.Method 23 67
// Строка вызовет исключение
// let lastlet = 10
member w.Method x y : unit =
let res = x * y
printfn $"Результат умножения %d{x} на %d{y} равен %d{res}"
type MyClass2() =
let c = 78
do
printfn "Первичный конструктор"
member w.Method x y : unit =
let res = x * y
printfn $"Результат умножения %d{x} на %d{y} равен %d{res}"
new(i: int) as this2 = MyClass2() then
this2.Method 98 12
Теоретическую статью подтверждает практический исходник с классами и их конструкторами на языке программирования F#.
Исходник написан в MS Visual Studio 2022 preview 5, протестирован в MS Visual Studio 2019. Проект состоит из нескольких модулей для раздельного тестирования каждого типа конструктора.
classesappfsharpconstructors-vs17.zip
CMyLabel - анимация текста 
Исходник программы смены обоев рабочего стола