Dalam posting ini kita akan melihat binding di F #, khususnya kita akan melihat Let / Use / Do. Sekarang Anda mungkin bertanya pada diri sendiri apa itu ikatan, dan karena kami belum memeriksanya, sekaranglah saatnya untuk membicarakannya.
Sederhananya, pengikat menghubungkan pengidentifikasi dengan nilai atau fungsi.
Biarkan
Anda menggunakan kata kunci let untuk mengaitkan nama dengan nilai atau fungsi. Sebenarnya ada penggunaan Let yang berbeda secara halus, di mana satu dinyatakan di tingkat atas dalam modul, dan yang lain di mana kita mendefinisikan beberapa konteks lokal. Berikut adalah contoh keduanya:
module DemoModule = let someFunction = let a = 1 let b = 2 a * b
Kita dapat mengakses someFunction menggunakan nama yang sepenuhnya memenuhi syarat, seperti DemoModule.someFunction, tetapi binding Let bersarang (a, b) hanya tersedia untuk tingkat atas Biarkan. Biasanya Anda melihat lebih banyak kasus ketika kami menggunakan Biarkan mengikat untuk mendeklarasikan beberapa nilai dari modul internal, jadi mari kita memusatkan upaya kami di sana (meskipun penting untuk mengetahui bahwa Anda dapat menggunakan Biarkan di tingkat modul).
Jadi mari kita lihat beberapa contoh lagi.
let aString ="this is a string" let aInt = 12 let aDecimal = 12.444 let aPiFunction () = Math.PI let aSquareRootFunction (x) = Math.Sqrt(x) let aFullyTypedSquareRootFunction (x :float) = Math.Sqrt(x) let a,b = "a","tuple"
Anda dapat melihat bahwa kita dapat menggunakan Biarkan mengikat untuk mengikat ke beberapa nilai, yang bisa dari berbagai jenis, seperti:
- Integer
- Desimal
- Berfungsi tanpa parameter input
- Berfungsi dengan parameter input (di mana sistem inferensi logis tipe F # akan memilih jenis dengan benar)
- Fungsi yang memiliki tipe parameter yang sepenuhnya ditentukan
- Tuple (dalam hal ini, String * String tuple)
Di tempat lain, Anda dapat melihat Biarkan mengikat di kelas, tetapi kami akan membahas ini secara lebih rinci di artikel berikutnya dalam seri ini.
Anda dapat membaca lebih lanjut tentang Biarkan mengikat pada MSDN.Gunakan
Penjilidan Penggunaan sangat mirip dengan Biarkan mengikat, karena mengikat nilai ke hasil ekspresi. Perbedaan utama adalah bahwa pengikatan Penggunaan dirancang untuk bekerja dengan tipe IDisposable dan secara otomatis menghapus nilai ketika tidak lagi dalam ruang lingkup. Ini sangat mirip dengan .NET menggunakan kata kunci, meskipun saya tidak percaya bahwa F # Penggunaan mengikat akan persis sama dengan menggunakan. NET, karena menggunakan kata kunci dalam. NET sebenarnya adalah percobaan / akhirnya dengan panggilan untuk Buang ) akhirnya.
Kami telah melihat contoh penggunaan mengikat di posting terakhir pada pemformatan teks, tetapi hanya untuk mengingatkan diri kita sendiri, mari kita lihat ini lagi.
use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") fprintf sw "This is a string line %s\r\n" "cat" fprintf sw "This is a int line %i" 10 sw.Close()
Dalam contoh ini, Gunakan jaminan yang mengikat bahwa metode StreamWriter akan memanggil metode Buang () setelah memanggil sw.Close (), ditunjukkan di atas.
Gunakan hanya karya dengan IDisposables, dan Anda akan mendapatkan kesalahan kompilasi jika Anda mencoba menggunakannya dengan hal lain, seperti yang ditunjukkan di bawah ini:
Karena metode Buang () dipanggil pada akhir pengikatan Penggunaan, kehati-hatian harus diambil untuk tidak mengembalikan nilai yang dikaitkan dengan Let.
let Write = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") sw
Jika Anda benar-benar harus memberikan IDisposable kembali, yang merupakan bagian dari pengikatan Penggunaan, Anda dapat menggunakan panggilan balik sebagai gantinya. Sesuatu seperti ini akan berhasil, tetapi saya akan berhenti dan bertanya pada diri sendiri apakah Anda merancang desain Anda dengan benar jika Anda melakukan hal-hal seperti itu:
let Write callback = use sw = new StreamWriter(@"c:\temp\fprintfFile.txt") fprintf sw "Write is writing to the StreamWriter" callback sw sw let callback sw = fprintf sw "sw is the StreamWriter" let disp = Write callback
Lakukan
Penjilidan do digunakan untuk mengeksekusi kode tanpa mendefinisikan fungsi atau nilai. Binding HARUS selalu mengembalikan Unit (tidak ada nilai / batal). Dalam banyak kasus, Anda dapat menghilangkan Do binding dan semuanya akan berfungsi seperti yang diharapkan.
Berikut adalah beberapa contoh penggunaan Do bindings.
do printf "doing the do" //oh oh not a unit do printf "print a sum %i" 1 + 1 do 1 + 1
Jika saya sebaliknya menunjukkan tangkapan layar dengan kode di atas, Anda akan melihat bahwa kompiler akan mengeluh jika Anda mencoba menggunakan Do dengan hasil non-Unit.
Anda memiliki dua opsi:
- Gunakan operator pipelined untuk mengabaikan hasilnya
- Buat biarkan mengikat
Saya menunjukkan contoh masing-masing di bawah ini:
let x = 1 + 1 do printf "print a sum %i" x do (1+1 |> ignore)
Biarkan! Gunakan! Lakukan!
Meskipun saya belum ingin membahasnya, terkadang Anda mungkin secara tidak sengaja melihat Let! Gunakan! Lakukan !, dan ketika Anda melakukan ini, ini adalah bagian dari apa yang disebut sebagai ekspresi komputasi. Anda kemungkinan besar akan melihat ini di alur kerja asinkron F #, yang akan kita bahas di salah satu artikel terakhir. Jika saya cukup mengerti, saya bahkan dapat mencoba menjelaskan bagaimana Anda dapat membuat "Ekspresi Komputasi" Anda sendiri, meskipun mereka adalah konsep yang agak abstrak dan topik yang agak rumit, jadi sekarang bukan saatnya bagi mereka.