F# 6'daki yenilikler

F# 6, F# diline ve F# Etkileşimli'ye çeşitli geliştirmeler ekler. .NET 6 ile yayınlanır.

En son .NET SDK'sını .NET indirmeleri sayfasından indirebilirsiniz.

Get started

F# 6 tüm .NET Core dağıtımlarında ve Visual Studio araçlarında kullanılabilir. Daha fazla bilgi için bkz. F# kullanmaya başlama.

{...} görevi

F# 6, görev ifadelerini kullanarak F# kodunda .NET görevleri yazmak için yerel destek içerir. Görev ifadeleri, eşzamansız ifadelere benzer, ancak .NET görevlerini doğrudan yazmanıza olanak tanır.

Örneğin, bir .NET-uyumlu görev oluşturmak için aşağıdaki F# kodunu göz önünde bulundurun.

let readFilesTask (path1, path2) =
   async {
        let! bytes1 = File.ReadAllBytesAsync(path1) |> Async.AwaitTask
        let! bytes2 = File.ReadAllBytesAsync(path2) |> Async.AwaitTask
        return Array.append bytes1 bytes2
   } |> Async.StartAsTask

F# 6 kullanılarak bu kod aşağıdaki gibi yeniden yazılabilir.

let readFilesTask (path1, path2) =
   task {
        let! bytes1 = File.ReadAllBytesAsync(path1)
        let! bytes2 = File.ReadAllBytesAsync(path2)
        return Array.append bytes1 bytes2
   }

F# 5 için mükemmel TaskBuilder.fs ve Ply kitaplıkları aracılığıyla görev desteği sağlandı. Kodu yerleşik desteğe geçirmek kolay olmalıdır. Ancak bazı farklılıklar vardır: ad alanları ve tür çıkarımı yerleşik destek ile bu kitaplıklar arasında biraz farklılık gösterir ve bazı ek tür ek açıklamaları gerekebilir. Gerekirse, bu topluluk kitaplıklarına açıkça başvuruda bulunursanız ve her dosyada doğru ad alanlarını açarsanız F# 6 ile bu topluluk kitaplıklarını kullanmaya devam edebilirsiniz.

task {…} kullanımı, async {…} kullanımına çok benzer. kullanmanın task {…} , yerine async {…}çeşitli avantajları vardır:

ek yükü task {...} daha düşüktür ve büyük olasılıkla zaman uyumsuz işlerin hızla yürütüldüğü yoğun kod yollarındaki performansı artırabilir.
task {…} için hata ayıklama adım izleme ve yığın izlemelerinde daha iyidir.
Görevleri bekleyen veya üreten .NET paketleriyle birlikte çalışma daha kolaydır.

hakkında async {…}bilgi sahibiyseniz, dikkat etmeniz gereken bazı farklılıklar vardır:

task {…} görevi ilk bekleme noktasına doğrudan yürütür.
task {…} bir iptal belirtecini örtük olarak yaymaz.
task {…} örtük iptal denetimleri gerçekleştirmez.
task {…} zaman uyumsuz tailcall'ları desteklemez. Bu, araya giren zaman uyumsuz beklemeler yoksa, return! .. özyinelemeli olarak kullanmanın yığın taşmalarına neden olabileceği anlamına gelir.

Genel olarak, görevleri kullanan .NET kütüphaneleriyle birlikte çalışıyorsanız ve zaman uyumsuz kod tailcall'larına veya örtük iptal belirteci yayılmasına güvenmiyorsanız, yeni kodda async {…} yerine task {…} kullanmayı düşünmelisiniz. Mevcut kodda, async {…}'in daha önce bahsedilen özelliklerine güvenmediğinizden emin olmak için kodunuzu gözden geçirdikten sonra yalnızca task {…}'e geçiş yapmanız gerekir.

Bu özellik F# RFC FS-1097'i uygular.

Daha basit indeksleme sözdizimi ile `expr[idx]`

F# 6, koleksiyonları dizinlemek ve dilimlemek için expr[idx] söz dizimini kullanmaya izin verir.

F# 5'e kadar ve dahil olmak üzere, F# expr.[idx] dizin söz dizimi olarak kullanmıştır. expr[idx] kullanımına izin vermek, F# öğrenenlerin veya F#'yi ilk kez görenlerin noktalı gösterim dizinlemesini standart endüstri uygulamasından gereksiz bir sapma olarak gördüklerine dair yinelenen geri bildirimlere dayanır.

Bu, mevcut işlevselliği bozan bir değişiklik değildir, çünkü varsayılan olarak expr.[idx] kullanımıyla ilgili hiçbir uyarı gösterilmez. Ancak, kod açıklamalarını öneren bazı bilgilendirme iletileri yayılır. İsteğe bağlı olarak daha fazla bilgi iletilerini de etkinleştirebilirsiniz. Örneğin, expr.[idx] gösteriminin kullanımlarını raporlamaya başlamak için isteğe bağlı bir bilgilendirme uyarısını /warnon:3366 etkinleştirebilirsiniz. Daha fazla bilgi için bkz. İndeksleme Gösterimi.

Yeni kodda, dizin oluşturma söz dizimi için expr[idx] kullanımını sistematik olarak öneririz.

Bu özellik F# RFC FS-1110 uygular.

Kısmi etkin desenler için yapı gösterimleri

F# 6, kısmi etkin desenler için isteğe bağlı yapı gösterimleriyle "etkin desenler" özelliğini genişletir. Bu, bir değer seçeneği döndürmek üzere kısmi etkin deseni kısıtlamak için bir öznitelik kullanmanıza olanak tanır:

[<return: Struct>]
let (|Int|_|) str =
   match System.Int32.TryParse(str) with
   | true, int -> ValueSome(int)
   | _ -> ValueNone

Özelliğin kullanılması gerekir. Kullanım sitelerinde kod değişmez. Net sonuç, ayırmaların azaltılmasıdır.

Bu özellik F# RFC FS-1039 uygular.

Hesaplama ifadelerinde aşırı yüklenmiş özel işlemler

F# 6, aşırı yüklenmiş yöntemler üzerinde CustomOperationAttribute kullanmanıza olanak tanır.

Hesaplama ifadesi oluşturucusunun contentaşağıdaki kullanımını göz önünde bulundurun:

let mem = new System.IO.MemoryStream("Stream"B)
let content = ContentBuilder()
let ceResult =
    content {
        body "Name"
        body (ArraySegment<_>("Email"B, 0, 5))
        body "Password"B 2 4
        body "BYTES"B
        body mem
        body "Description" "of" "content"
    }

body Burada özel işlem, farklı türlerde değişken sayıda bağımsız değişken alır. Bu, aşırı yükleme kullanan aşağıdaki oluşturucunun uygulanması tarafından desteklenir:

type Content = ArraySegment<byte> list

type ContentBuilder() =
    member _.Run(c: Content) =
        let crlf = "\r\n"B
        [|for part in List.rev c do
            yield! part.Array[part.Offset..(part.Count+part.Offset-1)]
            yield! crlf |]

    member _.Yield(_) = []

    [<CustomOperation("body")>]
    member _.Body(c: Content, segment: ArraySegment<byte>) =
        segment::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, bytes: byte[]) =
        ArraySegment<byte>(bytes, 0, bytes.Length)::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, bytes: byte[], offset, count) =
        ArraySegment<byte>(bytes, offset, count)::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, content: System.IO.Stream) =
        let mem = new System.IO.MemoryStream()
        content.CopyTo(mem)
        let bytes = mem.ToArray()
        ArraySegment<byte>(bytes, 0, bytes.Length)::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, [<ParamArray>] contents: string[]) =
        List.rev [for c in contents -> let b = Text.Encoding.ASCII.GetBytes c in ArraySegment<_>(b,0,b.Length)] @ c

Bu özellik F# RFC FS-1056 uygular.

"as" desenleri

F# 6'da, bir as desenin sağ tarafı artık bir desen olabilir. Bir tür testinin girişe daha güçlü bir tür vermesi durumunda bu önemlidir. Örneğin, aşağıdaki kodu göz önünde bulundurun:

type Pair = Pair of int * int

let analyzeObject (input: obj) =
    match input with
    | :? (int * int) as (x, y) -> printfn $"A tuple: {x}, {y}"
    | :? Pair as Pair (x, y) -> printfn $"A DU: {x}, {y}"
    | _ -> printfn "Nope"

let input = box (1, 2)

Her desen örneğinde giriş nesnesi tür testi yapılır. as modelinin sağ tarafının artık daha güçlü türdeki nesneyle eşleşebilen başka bir model olmasına izin verilir.

Bu özellik F# RFC FS-1105'i uygular.

Girinti söz dizimi düzeltmeleri

F# 6, girintiye duyarlı söz dizimi kullanımında bir dizi tutarsızlık ve sınırlamayı kaldırır. Bkz. RFC FS-1108. Bu, F# 4.0'dan bu yana F# kullanıcıları tarafından vurgulanan 10 önemli sorunu çözer.

Örneğin, F# 5'te aşağıdaki koda izin verildi:

let c = (
    printfn "aaaa"
    printfn "bbbb"
)

Ancak, aşağıdaki koda izin verilmedi (bir uyarı üretti):

let c = [
    1
    2
]

F# 6'da her ikisinde de izin verilir. Bu, F# dilini daha basit ve daha kolay öğrenilir hale getirir. F# topluluğu katkıda bulunan Hadrian Tang, özelliğin dikkat çekici ve son derece değerli sistematik testleri de dahil olmak üzere bu konuda öncülük etti.

Bu özellik F# RFC FS-1108'i uygular.

Ek örtük dönüştürmeler

F# 6'da, RFC FS-1093'te açıklandığı gibi ek "örtük" ve "türe yönlendirilmiş" dönüştürmelere destek sağladık.

Bu değişiklik üç avantaj getirir:

Daha az açık yukarı yayın gerekir
Açık tamsayı dönüşümlerine daha az ihtiyaç duyulmaktadır
.NET tarzı örtük dönüştürmelere birinci sınıf destek eklendi.

Bu özellik F# RFC FS-1093 uygular.

Ek örtük yukarı yayın dönüştürmeleri

F# 6, ek örtük yukarı yayın dönüştürmeleri uygular. Örneğin, F# 5 ve önceki sürümlerde, bir tür ek açıklaması mevcutken bile, ifadelerin farklı dallarda farklı alt türlere sahip olduğu bir işlevi uygularken dönüş ifadesi için yukarı dönüştürmeler gerekiyordu. Aşağıdaki F# 5 kodunu göz önünde bulundurun:

open System
open System.IO

let findInputSource () : TextReader =
    if DateTime.Now.DayOfWeek = DayOfWeek.Monday then
        // On Monday a TextReader
        Console.In
    else
        // On other days a StreamReader
        File.OpenText("path.txt") :> TextReader

Burada koşullu dallar sırasıyla TextReader ve StreamReader hesaplar, ve her iki dalın da StreamReader türüne sahip olmasını sağlamak için yukarı tür dönüştürme eklenmiştir. F# 6'da bu yukarı dönüşümler artık otomatik olarak ekleniyor. Bu, kodun daha basit olduğu anlamına gelir:

let findInputSource () : TextReader =
    if DateTime.Now.DayOfWeek = DayOfWeek.Monday then
        // On Monday a TextReader
        Console.In
    else
        // On other days a StreamReader
        File.OpenText("path.txt")

İsteğe bağlı olarak, ek örtük bir yukarı dönüşümün kullanıldığı her noktada uyarı göstermek için /warnon:3388 uyarısını etkinleştirebilirsiniz, bu durum Örtük dönüşümler için isteğe bağlı uyarılar bölümünde açıklandığı gibi.

Örtük tamsayı dönüştürmeleri

F# 6'da, her iki tür de bilindiğinde 32 bit tamsayılar 64 bit tamsayılara genişletilir. Örneğin, tipik bir API şeklini göz önünde bulundurun:

type Tensor(…) =
    static member Create(sizes: seq<int64>) = Tensor(…)

F# 5'te int64 veri türü için tamsayı değişmezleri kullanılmalıdır.

Tensor.Create([100L; 10L; 10L])

veya

Tensor.Create([int64 100; int64 10; int64 10])

F# 6'da, tür çıkarımı sırasında hem kaynak hem de hedef türü bilindiğinde, int32'den int64'e, int32'den nativeint'e ve int32'den double'e genişletme otomatik olarak gerçekleşir. Bu nedenle, önceki örneklerde olduğu gibi durumlarda int32 literaller kullanılabilir.

Tensor.Create([100; 10; 10])

Bu değişikliğe rağmen F# çoğu durumda sayısal türlerin açıkça genişletilmesi özelliğini kullanmaya devam eder. Örneğin, örtük genişletme işlemi, int8 veya int16 gibi diğer sayısal türler için ya da float32'dan float64'e dönüşümlerde ve kaynak veya hedef türü bilinmediğinde geçerli değildir. Ayrıca, örtük /warnon:3389 bölümünde açıklandığı gibi, örtük sayısal genişletmenin kullanıldığı her noktada uyarı gösterilmesi için uyarıyı isteğe bağlı olarak etkinleştirebilirsiniz.

.NET stili örtük dönüştürmelere birinci sınıf destek

F# 6'da yöntemleri çağırırken F# kodunda .NET "op_Implicit" dönüştürmeleri otomatik olarak uygulanır. Örneğin, F# 5'te XML için .NET API'leriyle çalışırken kullanılması XName.op_Implicit gerekiyordu:

open System.Xml.Linq
let purchaseOrder = XElement.Load("PurchaseOrder.xml")
let partNos = purchaseOrder.Descendants(XName.op_Implicit "Item")

F# 6'da, kaynak ifade ve hedef tür için türler kullanılabilir olduğunda, op_Implicit dönüşümleri parametre ifadelerine otomatik olarak uygulanır.

open System.Xml.Linq
let purchaseOrder = XElement.Load("PurchaseOrder.xml")
let partNos = purchaseOrder.Descendants("Item")

İsteğe bağlı olarak, /warnon:3395 yöntem bağımsız değişkenlerinde kullanılan op_Implicit dönüşüm genişletmesinin her noktasında bir uyarı göstermek üzere uyarıyı etkinleştirebilirsiniz. Bu, Örtük dönüşümler için isteğe bağlı uyarılar bölümünde açıklandığı gibidir.

Uyarı

F# 6'nın ilk sürümünde bu uyarı numarası idi /warnon:3390. Çakışma nedeniyle uyarı numarası daha sonra /warnon:3395 olarak güncelleştirildi.

Örtük dönüştürmeler için isteğe bağlı uyarılar

Türe yönelik ve örtük dönüştürmeler, tür çıkarımıyla kötü etkileşimde bulunabilir ve anlaşılması daha zor olan kodlara yol açabilir. Bu nedenle, bu özelliğin F# kodunda kötüye kullanılmamasını sağlamak amacıyla bazı önlemler vardır. İlk olarak, hem kaynak hem de hedef türü kesin olarak bilinmeli ve belirsizlik veya ek tür çıkarımı olmamalıdır. İkinci olarak, örtük dönüştürmelerin kullanımını raporlamak için kabul uyarıları etkinleştirilebilir ve varsayılan olarak bir uyarı açıktır:

/warnon:3388 (ek gizli yukarı çevrim)
/warnon:3389 (gizli sayısal genişletme)
/warnon:3391 (Varsayılan olarak açık olan metod dışı bağımsız değişkenlerde op_Implicit)
/warnon:3395 (yöntem bağımsız değişkenlerinde op_Implicit)

Ekibiniz örtük dönüştürmelerin tüm kullanımlarını yasaklamak istiyorsa, /warnaserror:3388, /warnaserror:3389, /warnaserror:3391 ve /warnaserror:3395 de belirtebilirsiniz.

İkili sayılar için biçimlendirme

F# 6, ikili sayı biçimleri için kullanılabilir biçim tanımlayıcılarına deseni ekler %B . Aşağıdaki F# kodunu göz önünde bulundurun:

printf "%o" 123
printf "%B" 123

Bu kod aşağıdaki çıkışı yazdırır:

173
1111011

Bu özellik F# RFC FS-1100 uygular.

Kullanım bağlamalarını iptal eder

F# 6 bir _ bağlamada kullanılmasına izin veriruse, örneğin:

let doSomething () =
    use _ = System.IO.File.OpenText("input.txt")
    printfn "reading the file"

Bu özellik F# RFC FS-1102 uygular.

InlineIfLambda

F# derleyicisi, kod için inlining gerçekleştiren bir iyileştirici içerir. F# 6'da, bir bağımsız değişkenin lambda işlevi olduğu belirlenirse, kod isteğe bağlı olarak bu bağımsız değişkenin her zaman çağrı noktalarında satır içi olması gerektiğini belirtmesine olanak tanıyan yeni bir bildirim özelliği ekledik.

Örneğin, bir diziden geçiş yapmak için aşağıdaki iterateTwice işlevi göz önünde bulundurun:

let inline iterateTwice ([<InlineIfLambda>] action) (array: 'T[]) =
    for j = 0 to array.Length-1 do
        action array[j]
    for j = 0 to array.Length-1 do
        action array[j]

Eğer çağrı konumu şöyleyse:

let arr = [| 1.. 100 |]
let mutable sum = 0
arr  |> iterateTwice (fun x ->
    sum <- sum + x)

Ardından, kod, inlining ve diğer iyileştirmelerden sonra şu hale gelir:

let arr = [| 1.. 100 |]
let mutable sum = 0
for j = 0 to arr.Length-1 do
    sum <- sum + arr[j]
for j = 0 to arr.Length-1 do
    sum <- sum + arr[j]

F# uygulamasının önceki sürümlerinden farklı olarak bu iyileştirme, söz konusu lambda ifadesinin boyutu ne olursa olsun uygulanır. Bu özellik, döngü açma ve benzer dönüştürmeleri daha güvenilir uygulamak için de kullanılabilir.

Kodunuzda /warnon:3517 bağımsız değişkenlerin çağrı sitelerindeki lambda ifadelerine bağlı olmadığı yerleri belirtmek için bir kabul etme uyarısı (InlineIfLambdavarsayılan olarak kapalı) açılabilir. Normal durumlarda bu uyarı etkinleştirilmemelidir. Ancak, belirli yüksek performanslı programlama türlerinde, tüm kodların çizili ve düzleştirilmiş olduğundan emin olmak yararlı olabilir.

Bu özellik F# RFC FS-1098'i uygular.

Devam ettirilebilen kod

task {…} F# 6 desteği, "yeniden devam ettirilebilir kod" temelli RFC FS-1087 üzerinde kurulmuştur. Devam ettirilebilen kod, çok sayıda yüksek performanslı zaman uyumsuz ve verimli durum makinesi oluşturmak için kullanılabilen teknik bir özelliktir.

Ek koleksiyon işlevleri

FSharp.Core 6.0.0, çekirdek koleksiyon işlevlerine beş yeni işlem ekler. Bu işlevler şunlardır:

List/Array/Seq.insertAt
List/Array/Seq.removeAt
List/Array/Seq.updateAt
List/Array/Seq.insertManyAt
List/Array/Seq.removeManyAt

Bu işlevlerin tümü ilgili koleksiyon türü veya dizisinde kopyalama ve güncelleştirme işlemleri gerçekleştirir. Bu işlem türü bir "işlevsel güncelleştirme" biçimidir. Bu işlevleri kullanma örnekleri için, ilgili belgelere (örneğin , List.insertAt) bakın.

Örnek olarak, Elmish stilinde yazılmış basit bir "Yapılacaklar Listesi" uygulaması için model, ileti ve güncelleştirme mantığını göz önünde bulundurun. Burada kullanıcı uygulamayla etkileşim kurarak ileti oluşturur ve update işlev bu iletileri işleyerek yeni bir model oluşturur:

type Model =
    { ToDo: string list }

type Message =
    | InsertToDo of index: int * what: string
    | RemoveToDo of index: int
    | LoadedToDos of index: int * what: string list

let update (model: Model) (message: Message) =
    match message with
    | InsertToDo (index, what) ->
        { model with ToDo = model.ToDo |> List.insertAt index what }
    | RemoveToDo index ->
        { model with ToDo = model.ToDo |> List.removeAt index }
    | LoadedToDos (index, what) ->
        { model with ToDo = model.ToDo |> List.insertManyAt index what }

Bu yeni işlevlerle mantık net ve basittir ve yalnızca sabit verilere dayanır.

Bu özellik F# RFC FS-1113'i uygular.

Haritalar anahtarlar ve değerlere sahiptir

FSharp.Core 6.0.0'da türü Map artık Anahtarlar ve Değerler özelliklerini destekler. Bu özellikler temel alınan koleksiyonu kopyalamaz.

Bu özellik F# RFC FS-1113'te belgelenmiştir.

NativePtr için ek iç bilgiler

FSharp.Core 6.0.0 , NativePtr modülüne yeni iç bilgiler ekler:

NativePtr.nullPtr
NativePtr.isNullPtr
NativePtr.initBlock
NativePtr.clear
NativePtr.copy
NativePtr.copyBlock
NativePtr.ofILSigPtr
NativePtr.toILSigPtr

NativePtr içindeki diğer işlevlerin aksine, bu işlevler de satıriçi işlevlerdir ve /nowarn:9 kullanılmadığı takdirde uyarılar gösterir. Bu işlevlerin kullanımı yönetilmeyen türlerde sınırlıdır.

Bu özellik F# RFC FS-1109'da belgelenmiştir.

Birim ek açıklamalarıyla ek sayısal türler

F# 6'da, aşağıdaki türler veya tür kısaltma takma adları artık ölçü birimi açıklamalarını desteklemektedir. Yeni eklemeler kalın olarak gösterilir:

F# diğer adı	CLR Türü
`float32`/`single`	`System.Single`
`float`/`double`	`System.Double`
`decimal`	`System.Decimal`
`sbyte`/`int8`	`System.SByte`
`int16`	`System.Int16`
`int`/`int32`	`System.Int32`
`int64`	`System.Int64`
`byte`/`uint8`	`System.Byte`
`uint16`	`System.UInt16`
`uint`/`uint32`	`System.UInt32`
`uint64`	`System.UIn64`
`nativeint`	`System.IntPtr`
`unativeint`	`System.UIntPtr`

Örneğin, işaretsiz bir tamsayıya aşağıdaki gibi ek açıklama ekleyebilirsiniz:

[<Measure>]
type days

let better_age = 3u<days>

Bu özellik F# RFC FS-1091'de belgelenmiştir.

Nadiren kullanılan sembolik işleçler için bilgilendirici uyarılar

F# 6, F# 6 ve sonrasında , :=, !ve incr kullanımını decrnormalden çıkaran geçici yönergeler ekler. Bu işleçlerin ve işlevlerin kullanılması, kodunuzu özelliğin açık kullanımıyla Value değiştirmenizi gerektiren bilgilendirici iletiler oluşturur.

F# programlama dilinde, başvuru hücreleri yığında ayrılmış değişken yazmaçlar için kullanılabilir. Bazen yararlı olsalar da, modern F# kodlamasında nadiren kullanılırlar, çünkü let mutable bunun yerine kullanılabilirler. F# çekirdek kitaplığı iki işleç := ve ! iki işlev incr içerir ve decr özellikle başvuru çağrıları ile ilgilidir. Bu işleçlerin varlığı, başvuru hücrelerini F# programlamada olması gerekenden daha merkezi hale getirir ve tüm F# programcılarının bu işleçleri bilmesini zorunlu kılar. Ayrıca, C# ve diğer dillerdeki ! işlemcisi ile not işlemi kolayca karıştırılabilir ve bu, kod çevirisi sırasında hataların incelikli bir kaynağı olabilir.

Bu değişikliğin mantığı, F# programcısının bilmesi gereken işleç sayısını azaltmak ve böylece yeni başlayanlar için F# dilini basitleştirmektir.

Örneğin, aşağıdaki F# 5 kodunu göz önünde bulundurun:

let r = ref 0

let doSomething() =
    printfn "doing something"
    r := !r + 1

İlk olarak, başvuru hücreleri modern F# kodlamasında nadiren gereklidir, bunun let mutable yerine normalde kullanılabilir:

let mutable r = 0

let doSomething() =
    printfn "doing something"
    r <- r + 1

Başvuru hücreleri kullanıyorsanız F# 6, son satırı r.Value <- r.Value + 1olarak değiştirmenizi isteyen ve başvuru hücrelerinin uygun kullanımıyla ilgili daha fazla kılavuza sizi bağlayan bilgilendirıcı bir uyarı yayar.

let r = ref 0

let doSomething() =
    printfn "doing something"
    r.Value <- r.Value + 1

Bu iletiler uyarı değildir; bunlar, IDE ve derleyici çıkışında gösterilen "bilgilendirme iletileridir". F# geriye dönük uyumluluğunu korur.

Bu özellik F# RFC FS-1111'i uygular.

F# araçları: Visual Studio'da betik yazımı için varsayılan .NET 6

Visual Studio'da bir F# Betiği (.fsx) açar veya yürütürseniz, betik varsayılan olarak 64 bit yürütme ile .NET 6 kullanılarak analiz edilir ve yürütülür. Bu işlev, Visual Studio 2019'un sonraki sürümlerinde önizleme aşamasındaydı ve artık varsayılan olarak etkindir.

.NET Framework betiğini etkinleştirmek için Araçlar>Seçenekler>F# Araçları>F# Etkileşimli'yi seçin. .NET Core Betiği Kullan'ıfalse olarak ayarlayın ve F# Etkileşimli penceresini yeniden başlatın. Bu ayar hem betik düzenlemeyi hem de betik yürütmeyi etkiler. .NET Framework betiği için 32 bit yürütmeyi etkinleştirmek amacıyla ayrıca 64-bit F# Interactive değerini false olarak ayarlayın. .NET Core betiği için 32 bit seçeneği yoktur.

F# araçları: F# betiklerinizin SDK sürümünü sabitleme

.NET SDK ayarına sahip global.json dosyası içeren bir dizinde dotnet fsi ile bir betik çalıştırırsanız, o zaman betiği çalıştırmak ve düzenlemek için listelenen .NET SDK sürümü kullanılır. Bu özellik F# 5'in sonraki sürümlerinde kullanılabilir.

Örneğin, bir dizinde .NET SDK sürüm ilkesi belirten aşağıdaki global.json dosyasını içeren bir betik olduğunu varsayalım:

{
  "sdk": {
    "version": "5.0.200",
    "rollForward": "minor"
  }
}

Betiği dotnet fsi kullanarak şimdi bu dizinden çalıştırırsanız, SDK sürümü dikkate alınacaktır. Bu, betiklerinizi derlemek, çözümlemek ve yürütmek için kullanılan SDK'yı "kilitlemenizi" sağlayan güçlü bir özelliktir.

Betiğinizi Visual Studio'da ve diğer IDE'lerde açar ve düzenlerseniz, betiğinizi analiz edip denetlerken araçlar bu ayara saygı gösterir. SDK bulunamazsa geliştirme makinenize yüklemeniz gerekir.

Linux ve diğer Unix sistemlerinde bunu bir shebang ile birleştirerek betiğin doğrudan yürütülmesi için bir dil sürümü de belirtebilirsiniz. Basit bir shebang script.fsx için kullanılabilir:

#!/usr/bin/env -S dotnet fsi

printfn "Hello, world"

Artık betik, script.fsx ile doğrudan yürütülebilir. Bunu aşağıdaki gibi belirli, varsayılan olmayan bir dil sürümüyle birleştirebilirsiniz:

#!/usr/bin/env -S dotnet fsi --langversion:5.0