Apakah VB benar-benar tidak peka huruf besar / kecil?


122

Saya tidak mencoba memulai argumen di sini, tetapi untuk alasan apa pun, biasanya dinyatakan bahwa Visual Basic tidak peka huruf besar dan bahasa C tidak (dan entah bagaimana itu hal yang baik).

Tapi inilah pertanyaan saya: Di mana tepatnya Visual Basic case insensitive? Saat saya mengetik ...

Dim ss As String
Dim SS As String

... ke dalam Visual Studio 2008 atau Visual Studio 2010 IDE, yang kedua memiliki peringatan " Variabel lokal SSsudah dideklarasikan di blok saat ini ". Di VBA VBE, itu tidak langsung menendang kesalahan, melainkan hanya mengoreksi kasus secara otomatis.

Apakah saya kehilangan sesuatu di sini dengan argumen ini bahwa Visual Basic tidak peka huruf besar-kecil? (Juga, jika Anda tahu atau ingin menjawab, mengapa itu menjadi hal yang buruk?)

Mengapa saya bahkan menanyakan pertanyaan ini?

Saya telah menggunakan Visual Basic dalam banyak dialeknya selama bertahun-tahun sekarang, kadang-kadang sebagai penghobi, kadang-kadang untuk program yang berhubungan dengan bisnis kecil dalam sebuah kelompok kerja. Dalam enam bulan terakhir, saya telah mengerjakan proyek besar, jauh lebih besar dari yang saya perkirakan. Sebagian besar kode sumber sampel di luar sana ada di C #. Saya tidak memiliki keinginan membara untuk belajar C #, tetapi jika ada hal-hal yang saya lewatkan pada penawaran C # yang tidak dimiliki Visual Basic (sebaliknya VB.NET menawarkan XML Literals ), maka saya ingin untuk mengetahui lebih banyak tentang fitur itu. Jadi dalam kasus ini, sering diperdebatkan bahwa bahasa C peka huruf besar kecil dan itu bagus dan Visual Basic tidak peka huruf besar / kecil dan itu buruk. Saya ingin tahu ...

  1. Bagaimana tepatnya Visual Basic tidak peka huruf besar / kecil karena setiap contoh di editor kode menjadi peka huruf besar / kecil (artinya kasusnya diperbaiki) apakah saya menginginkannya atau tidak.
  2. Apakah ini cukup menarik bagi saya untuk mempertimbangkan pindah ke C # jika casing VB.NET entah bagaimana membatasi apa yang dapat saya lakukan dengan kode?

5
+1 Saya pernah bertanya-tanya tentang hal yang sama persis sebelumnya.
NakedBrunch

7
Ummm ... tidak yakin bahwa Anda memahami arti case- in sensitive. Karena VB sebenarnya case insensitive, SS dan ss adalah nama yang sama, sedangkan di C mereka tidak akan sama.
Ed S.

1
@ed: Saya tidak dapat menggunakan keduanya SSdan ssdi VB, mana saja yang saya gunakan pertama kali adalah yang digunakan editor.
Todd Main

1
Otaku, saya merekomendasikan agar pertanyaan ini tetap fokus pada apa artinya mengatakan VB tidak peka huruf besar dan bagaimana itu diimplementasikan. Pertanyaan tentang apakah lebih baik bahasa yang tidak peka huruf besar / kecil mungkin, sayangnya, memulai perang api. Jika Anda benar-benar penasaran, tanyakan di pertanyaan lain. (Saya menyarankan Anda untuk tidak melakukannya, tetapi jika Anda harus menandainya secara subjektif dan menjadikannya wiki komunitas)
MarkJ

16
Anda sedang (atau dulu) memikirkan hal ini secara terbalik. Justru karena kompiler tidak peka huruf besar / kecil sehingga kesalahan membaca 'variabel SS sudah dideklarasikan'. Jika peka huruf besar kecil Anda akan mendapatkan salah satu 'variabel ss tidak digunakan' atau tidak ada kesalahan sama sekali dan bug jika Anda menggunakan alternatif satu dan yang lain.
Adriano Varoli Piazza

Jawaban:


108

Perbedaan antara VBA dan VB.NET hanya karena VB.NET terus dikompilasi di latar belakang. Anda akan mendapatkan kesalahan saat Anda mengompilasi VBA.

Seperti kata Jonathan , ketika pemrograman Anda dapat menganggap VB.NET sebagai case-insensitive selain dari string-comparisons, XML, dan beberapa situasi lainnya ...

Saya pikir Anda tertarik dengan apa yang ada di balik terpal. Nah, .NET Common Language Runtime peka huruf besar kecil , dan kode VB.NET bergantung pada waktu proses, jadi Anda dapat melihatnya harus peka huruf besar / kecil pada waktu proses, misalnya saat mencari variabel dan metode.

Kompiler dan editor VB.NET membiarkan Anda mengabaikannya - karena mereka memperbaiki kasus dalam kode Anda.

Jika Anda bermain-main dengan fitur dinamis atau late-binding (Option Strict Off) Anda dapat membuktikan bahwa run-time yang mendasarinya peka huruf besar / kecil. Cara lain untuk melihatnya adalah dengan menyadari bahwa bahasa case-sensitive seperti C # menggunakan runtime yang sama, sehingga runtime jelas mendukung case-sensitive.

EDIT Jika Anda ingin mengeluarkan IDE dari persamaan, Anda selalu dapat mengompilasi dari baris perintah . Edit kode Anda di Notepad sehingga memiliki ssdan SSdan lihat apa yang dilakukan kompilator.

EDIT Kutipan dari Jeffrey Richter di .NET Framework Design Guidelines halaman 45.

Agar jelas, CLR sebenarnya peka huruf besar / kecil. Beberapa bahasa pemrograman, seperti Visual Basic, tidak membedakan huruf besar / kecil. Ketika compiler Visual Basic mencoba menyelesaikan panggilan metode ke tipe yang didefinisikan dalam bahasa case-sensitive seperti C #, compiler (bukan CLR) mencari tahu kasus sebenarnya dari nama metode dan menyematkannya dalam metadata. CLR tidak tahu apa-apa tentang ini. Sekarang jika Anda menggunakan refleksi untuk mengikat ke suatu metode, API refleksi memang menawarkan kemampuan untuk melakukan pencarian tidak peka huruf besar / kecil. Sejauh ini CLR menawarkan ketidakpekaan huruf besar / kecil.


Jawaban terbaik yang pernah saya dengar sejauh ini. Apakah ada cara untuk membuktikan hal ini bahwa kompiler dan editor VB.Net membiarkan Anda mengabaikannya ? Apakah ada cara untuk menonaktifkan koreksi otomatis? Atau adakah cara untuk mengkompilasi sln yang tidak ditulis dalam VS IDE di MSBuild yang menggunakan keduanya ssdan SSakan mengkompilasi dan bekerja seperti yang diharapkan?
Todd Main

5
Anda dapat mematikan koreksi otomatis dengan cara curang. Klik kanan pada file vb dan pilih "Open With". Kemudian pilih sesuatu seperti "XML (Text) Editor". Anda akan kehilangan semua fungsi khusus VB seperti koreksi otomatis.
Jonathan Allen

+1 jawaban yang bagus, dan pertanyaan yang bagus juga Otaku (saya pikir Anda sudah tahu tetapi ingin mendapatkan definisi yang baik, hei?)
Tipe Anonim

Compiler / IDE VB.NET tidak 100% case-insensitive. Misalnya Dim pdfWriter As PDFWriterbenar-benar valid. VB.NET memungkinkan Anda untuk membedakan antara nama kelas dan nama variabel, yang merupakan sentuhan yang bagus, karena ini praktik umum dalam bahasa yang sepenuhnya peka huruf besar / kecil.
ingredient_15939

Cara VB tepat untuk interoperabilitas. Contoh: Buat DLL di C # dengan email sebagai String dan Email () sebagai properti dengan peristiwa inotifypropertychanged di dalamnya. C # akan mengkompilasi dengan baik dan DLL akan dibuat. Cobalah untuk merujuk DLL ini dalam VB atau bahasa serupa. Ini akan mengatakan ada konflik dalam variabel email / Email di perpustakaan. Alat analisis kode menunjukkan ini sebagai masalah di kompiler C # bukan di kompiler VB.
Venkat

22

Bagian dari masalah di sini adalah Anda perlu membagi bahasa dari pengalaman IDE.

Sebagai bahasa, VB.NET tentu saja tidak peka huruf besar / kecil sehubungan dengan pengidentifikasi. Menelepon DateTime.Parsedan datetime.parseakan terikat ke kode yang sama persis. Dan tidak seperti bahasa seperti C #, tidak mungkin mendefinisikan metode atau tipe yang hanya berbeda berdasarkan kasus.

Sebagai IDE, VB.NET mencoba untuk mempertahankan kasus pengidentifikasi yang ada ketika itu cukup mencantumkan blok kode. Daftar cantik terjadi setiap kali Anda keluar dari baris kode logis saat ini. Dalam hal ini Anda pindah dari deklarasi kedua SS, lister cantik memperhatikan ada pengenal yang ada dengan nama itu dan mengoreksinya agar memiliki case yang cocok.

Namun, perilaku ini murni dilakukan sebagai nilai tambah pengguna. Ini bukan bagian dari bahasa inti.


1
Terima kasih Jared, menarik untuk mengetahui bahwa itu hanya IDE. Saya masih gagal untuk memahami mengapa akan lebih baik jika memiliki lebih dari satu nama yang mewakili hal yang berbeda hanya dengan perbedaan kasus dalam nama, tapi saya rasa itu untuk hari lain.
Todd Main

1
Saya tidak berpikir Jared berarti itu hanya IDE. Saya pikir dia telah mengatakan compiler adalah case-sensitive, jadi berpikir ssidentik dengan SS, tetapi juga sebagai bantuan untuk membaca mengoreksi IDE SSuntuk sssaat Anda mengetik. Jadi, meskipun IDE tidak memperbaiki kasus tersebut, compiler akan tetap melihat kedua ID tersebut identik.
MarkJ

2
"Saya masih gagal untuk memahami mengapa akan lebih baik jika memiliki lebih dari satu nama yang mewakili hal yang berbeda hanya dengan perbedaan kasus dalam nama" <- Saya merasakan hal yang sama sebelum beralih dari VBA / VB6 / VB.NET ke C # , Saya pikir memiliki nama yang hanya berbeda menurut kasus tampaknya berbahaya. Namun dalam praktiknya, ini terbukti sangat berguna, dan, yang mengejutkan, tidak rentan terhadap kesalahan sama sekali.
Mike Rosenblum

2
@Mike Saya sangat tidak setuju dengan hal itu. Saya belum pernah melihat nama bersusun campuran yang melakukan apa pun selain menyebabkan kebingungan.
JaredPar

2
Betulkah? Maksud saya sesuatu seperti void SetColor (color Color) {this.color = color}; Saya menyadari bahwa ini mungkin terlihat berbahaya, tetapi bekerja dengan lancar, kompiler tidak akan membiarkan Anda membuat kesalahan, dan IntelliSense memberi Anda anggota yang benar setelah "warna". vs. "Warna". Hal yang mengganggu saya di sini adalah bahwa penggunaan "ini" tidak diperlukan - ini diberlakukan oleh FxCop dan / atau StyleCop (saya lupa yang mana), tapi saya berharap ada pengaturan agar IDE selalu memberlakukan ini saat mengakses kelas anggota alih-alih berpotensi membiarkan cakupan secara tidak sengaja dibayangi.
Mike Rosenblum

16

VB sebagian besar tidak peka huruf besar / kecil, tetapi ada pengecualian. Misalnya, literal dan pemahaman XML peka huruf besar / kecil. Perbandingan string biasanya case sensitive, tidak seperti T-SQL, tetapi ada switch compiler untuk membuat perbandingan string tidak case sensitive. Dan tentu saja ada kasus tepi saat berurusan dengan pewarisan, COM, dan Dynamic Language Runtime.


3
Poin bagus di mana kasus memang penting seperti Literal XML dan perbandingan string. Tetapi ketika kita mengatakan bahwa sebagian besar tidak peka huruf besar / kecil, apa sebenarnya yang kita bicarakan? Pindah ke Outlook VBA, hanya sebagai contoh, jika saya mengetik Dim mi as mailitemdan subject = mi.subject, nama objek akan dikoreksi otomatis menjadi MailItemdan mi.Subject. Apakah penyusun peduli (karena akan selalu mengoreksi ini secara otomatis) atau apakah ini kode cantik atau ...?
Todd Main

1
Kompilator tidak peduli. Anda dapat menguji ini dengan mengedit file di notepad dan menggunakan kompiler baris perintah.
Jonathan Allen

9

Ya, kompilator VB.NET memperlakukan pengidentifikasi dengan cara yang tidak peka huruf besar / kecil. Dan ya, itu bisa menyebabkan masalah saat menggunakan rakitan yang ditulis dalam bahasa lain atau menggunakan komponen COM. Kasus pertama tercakup dalam Spesifikasi Bahasa Umum . Aturan yang relevan adalah:

Agar dua pengenal dianggap berbeda, keduanya harus berbeda lebih dari sekadar kasusnya.

Kasus COM agak ditangani secara kasar oleh pembuat pustaka tipe, ini memaksa casing pengenal dengan nama yang sama menjadi identik. Meskipun pengenal tersebut memiliki peran yang berbeda. Dengan kata lain, parameter metode dengan nama "indeks" akan memaksa nama metode "Indeks" untuk dikembalikan ke "indeks". Itu telah menghasilkan lebih banyak garukan kepala, seperti yang Anda bayangkan :)


6

VB melindungi huruf besar / kecil (dalam IDE) tetapi tidak membedakan huruf besar / kecil . Ini seperti sistem file Windows. Hello.txt dan hello.txt dianggap sebagai nama file yang sama.

IDE mengasumsikan bahwa deklarasi variabel adalah kasus yang "benar" untuk variabel itu, dan menyesuaikan setiap instance variabel itu cocok dengan deklarasi tersebut. Ini dilakukan untuk alasan konsistensi dan eye-candy, tetapi bukan untuk fungsionalitas.

Saya telah melihat beberapa contoh di mana case tidak secara otomatis diubah agar sesuai dengan deklarasi, dan pernyataan itu berfungsi sama. Anda juga dapat menggunakan editor teks apa pun untuk menulis kode yang akan dikompilasi dengan baik dalam berbagai kasus.

Catatan samping:

Kebanyakan ORANG berpikir dengan cara yang tidak peka huruf besar / kecil. Ketika kita melihat kata "anjing", kata itu diterjemahkan ke dalam makna di benak kita. Arti kata tersebut tidak didasarkan pada kasus (yaitu terlepas dari apakah mengejanya "DOG", "DoG", atau "DOG" masih menggonggong.) KOMPUTER melihat kata-kata sebagai kantong bit terpisah. Huruf besar dan huruf kecil adalah pola bit yang berbeda, dan karenanya berbeda.

Karena sebagian besar pemrogram adalah manusia, ketidakpekaan huruf besar / kecil tampaknya lebih disesuaikan dengan cara orang berpikir dan sensitivitas huruf lebih banyak tentang manusia yang menyesuaikan cara mereka berpikir dengan batasan mesin.


4
Kecuali programmer perlu membedakan antara objek dan kelas, dan secara tradisional menggunakan perubahan dalam kasus untuk melakukannya (tidak diperlukan, hanya konvensi). Sehingga object.method()dan Object.Method()langsung dikenali sebagai referensi dan metode objek dan kelas (jika Anda sesuai dengan konvensi pengkodean itu). Sama seperti dalam bahasa Inggris, Anda membedakan kata benda dan awal kalimat dengan huruf besar. Jadi ketika membaca atau memprogram saya tidak berpikir huruf besar / kecil, jika tidak saya akan kehilangan beberapa makna.
Jason S

@Jason, Ini semua tentang apa yang biasa Anda lakukan. Siswa pemrograman C baru menawarkan banyak sekali keluhan tentang sensitivitas huruf pada awalnya, kemudian, setelah beberapa kursus, biasakanlah. The object.method () dan Object.Method () hanyalah konvensi, dan kasus terkuat untuk sensitivitas huruf. Saya harus memodifikasi program yang ditulis oleh orang lain yang memiliki dua variabel bernama temp dan Temp dalam lingkup yang sama, dan saya akan memberi tahu Anda bahwa sangat sulit untuk menyimpannya langsung di kepala saya. Dan meskipun kita mungkin mengenali kata benda umum melalui penggunaan huruf besar, kata "bob" dan "Bob" memiliki arti yang sama di otak kita.
Andrew Neely

Mengapa IDE menyimpan kasus dalam kasus itu? (Maaf). Saya pikir IDE mempertahankan case karena desainer MS berpikir case memiliki beberapa semantik, di otak, yang memang dilakukannya. Tetapi pada kenyataannya VB IDE menganggap formdan Formhal yang sama, yang bagi saya, membingungkan. Dalam kasus (maaf lagi), dari tempdan TempAnda dapat dengan mudah menggunakan alat pemfaktoran ulang di C # untuk mengganti nama Tempmenjadi bobTempatau apa pun. Namun, saya mempertahankan beberapa VB dan seseorang telah pergi dan melakukannya Dim form As Form. Sekarang ketika saya mengganti nama, itu mengganti nama kelas dan referensi objek. Bleah!
Jason S

@Jason, di VB saya selalu bilang "Redupkan aform as Form", tapi saya ngelantur. VB mendukung sensitivitas huruf dalam pencarian. Saya juga akan mencari "As Form" dan menggantinya dengan "sesuatu yang bodoh", lalu mengubah nama formulir menjadi sesuatu yang masuk akal, lalu mengganti nama "sesuatu yang bodoh" kembali ke "Sebagai Formulir". Saya benar-benar suka mengubah kasus, karena itu memverifikasi bahwa saya tidak menyalahkan nama variabel.
Andrew Neely

Ya, tetapi ini bukan pengganti alat pemfaktoran ulang yang akan membedakan antara referensi kelas dan instance jika namanya sama (atau hanya berbeda menurut kasus di VB). Alat refactoring C # sepertinya bisa melakukan itu. Saya tidak menamai kelas dan instance dengan sama. Di C # saya akan menggunakan case untuk membedakan, tapi di VB saya tidak bisa melakukannya jadi saya menggunakan huruf untuk menambahkan. Jelas masalah saya adalah saya mempertahankan kode orang lain yang telah menggunakan nama yang sama. Tapi diskusi ini menjadi terlalu besar untuk dikomentari, jadi saya akan tinggalkan di sini.
Jason S

5

Ini adalah bagian dari editor yang Anda gunakan, mereka mungkin berperilaku berbeda tetapi kenyataannya Visual Basic benar - benar bahasa yang tidak peka huruf besar / kecil. Jadi, ssdan SSsama.

Silakan lihat tutorial Dasar-dasar VB.NET untuk informasi lebih lanjut :)


Oh, itu menarik. adakah tempat saya melihat detail ini? saya belum mengujinya, tetapi memikirkan tentang VBScript, Anda mungkin benar.
Todd Main

@Otaku: silakan lihat jawaban saya lagi, saya telah memberikan tautannya sekarang. Terima kasih
Sarfraz

Saya cukup akrab dengan VB, terima kasih :) Saya tidak yakin apa yang Anda ingin saya lihat di halaman itu.
Todd Main

3

Saya tidak yakin saya mengerti Anda? VB tidak peka huruf besar / kecil, jadi ss dan SS adalah variabel yang sama, sehingga kompilator dengan benar mengeluh bahwa Anda mendeklarasikan ulang variabel tersebut.

Saya pikir Variabel tidak case sensitive, tetapi nama fungsinya.


tetapi jika saya menggunakan ssdan kemudian mengetik SS, itu akan dikoreksi secara otomatis ss, yang membuat saya percaya bahwa kompilator memang peduli dengan kasus.
Todd Main

5
@oTAKU: Itu adalah IDE yang mengubah kasus, bukan kompilernya.
John Saunders

2
VB masih tidak terlalu peduli dengan kasus. IDE mencoba membersihkan kode agar variabel tetap sama.
guitarthrower

1

Ya, VB tidak membedakan huruf besar / kecil. Kadang-kadang melempar mereka yang tidak terbiasa untuk sedikit loop.


1

Seseorang tidak perlu mencoba terlalu keras di VB.NET untuk membuat kode dengan "ejaan" huruf besar / kecil yang berbeda dari sebuah pengenal. Mengubah casing pengenal di file yang dideklarasikan tanpa menggunakan fungsi "Ubah nama" tidak akan menyebabkan nama diperbarui di file lain, meskipun mengedit baris apa pun yang berisi nama akan membuatnya sesuai dengan definisi saat ini.

Dengan cara ini, seseorang dapat menentukan bahwa VB.NET sebagian besar tidak peka huruf besar / kecil, tetapi itu membuat kasus pengidentifikasi tersedia untuk CLR yang dapat menggunakan informasi itu dengan cara yang peka huruf besar / kecil.


1

Saya hanya dapat menawarkan ini, yang seingat saya dari buku teks pemrograman saya di awal 80-an, adalah bahwa bahasa case-senstive, (pada saat itu) secara ketat dimaksudkan untuk mengurangi kesalahan waktu kompilasi. Artinya, "ketelitian" dimaksudkan untuk mengembangkan disiplin pengkodean dengan akurasi yang lebih besar. Ternyata penambahan pelabelan yang tepat untuk variabel, kelas, metode, fungsi, dan apa pun yang ingin Anda masukkan ke sana, juga berevolusi.

Saya ingat hampir semua buku itu menyertakan pola yang direkomendasikan untuk memimpin kapitalisasi, huruf kecil, dll. Seperti yang kita semua tahu, banyak dari yang telah dibuang atau harus saya katakan, diabaikan dalam praktiknya, kecuali untuk rumah produksi kelas atas, dan Solusi CASE, atau bagi mereka yang telah mencapai tingkat keahlian yang lebih tinggi. Saya pikir setiap orang mengalami kurva pembelajaran ini.

Mengingat kemajuan bahasa dan IDE ini, pertanyaan yang lebih baik adalah, bahasa apa yang meningkatkan waktu pengembangan saya? Tentu saja jika Anda tidak terbiasa dengan masing-masing bahasa, pilihan Anda terbatas.


1

Saya akan mencoba menjawab pertanyaan kedua Anda.

"apakah ini cukup menarik bagi saya untuk mempertimbangkan pindah ke C # jika casing VB.NET entah bagaimana membatasi apa yang dapat saya lakukan dengan kode?"

Buat Layanan Web WCF menggunakan C #. Buat DataContract (1 Kelas). Satu dengan properti "string email". Lain dengan "string Email" sebagai properti lain. Pilihan Anda untuk dipahami sebagai email pribadi atau email kantor. Atau bisa juga dalam dua DataContracts yang berbeda.

Untuk C # ini bagus. Layanan web dibuat dengan baik. Program AC # dapat dengan mudah membuat WSDL dan semuanya baik-baik saja.

Sekarang coba buat WSDL dengan VB (versi apapun). Ini akan mengatakan "email" sudah dideklarasikan dan pembuatan WSDL gagal.

Seperti semua orang, saya berasumsi ini adalah kelemahan dalam bahasa VB. Tapi!!!

Gunakan FxCOP dan analisis kode C # asli. FxCOP mengatakan menggunakan email / Email adalah sebuah masalah. Merekomendasikan untuk menggunakan nama lain yang mendukung ketidakpekaan huruf besar / kecil. Perhatikan juga per tanggal .NET framework memiliki 106 bahasa pemrograman dan ada banyak bahasa yang memiliki sensitivitas huruf AKTIF. Kami semua bergerak menuju cloud dan ingin layanan kami dapat diakses oleh semua platform / bahasa pemrograman.

Jadi peka huruf besar / kecil adalah pilihan Anda dalam program Anda dan jika Anda pria C, Anda akan menyukainya. Jika program akan digunakan / diakses oleh program non C lainnya, Anda perlu mendukung ketidakpekaan huruf besar / kecil tetapi bahasa Anda adalah pilihan Anda.

http://en.wikipedia.org/wiki/Comparison_of_C_Sharp_and_Visual_Basic_.NET http://www.vbrad.com/article.aspx?id=65


Cloud menggunakan URI yang peka huruf besar / kecil (yang terutama penting bagi proxy dan server cache).
binki

1

Menyembunyikan simbol (mis. Bidang menyembunyikan lokal) juga tidak membedakan huruf besar / kecil.

Berikut ini contohnya :

Public Class C
    Public Name As String

    Public Function M(name As String) As Boolean
        Return String.Equals(name, Name) ' case differs
    End Function
End Class

Output kompiler VB.NET didekompilasi menjadi (dan karenanya setara dengan) C # berikut:

public class C
{
    public string Name;

    public bool M(string name)
    {
        return string.Equals(name, name); // both lowercase
    }
}

string.Equalsdilewatkan lapangan dua kali. Lokal tersembunyi, terlepas dari kasusnya. Bahasa ini tidak membedakan huruf besar / kecil.

Untuk merujuk anggota secara eksplisit, seperti bidang ini, Anda harus merujuk anggota tersebut melalui Me:

Return String.Equals(name, Me.Name) ' differentiate field from local

0

Saya belum melihat siapa pun mengomentari pertanyaan eksplisit ke-2 Anda di akhir: "2: apakah ini cukup menarik bagi saya untuk mempertimbangkan pindah ke C # jika casing VB.NET entah bagaimana membatasi apa yang dapat saya lakukan dengan kode?"

Saya lebih suka pendekatan opsi yang lebih banyak bahwa C # memungkinkan pemrogram memilih apakah daripada membatasi opsi pemrogram. Saya sangat suka C #, tetapi untuk sensitivitas huruf saja, saya bahkan tidak akan berpikir itu dekat dengan belajar bahasa hanya karena peka huruf besar / kecil. semua fitur penting, dan ketika saya melihat keuntungan dari keduanya, C # dan VB.NET, saya sangat memilih C #. tetapi saya akan memberikan perspektif yang benar-benar seimbang, bias ya, karena saya memiliki preferensi, tetapi saya akan jujur ​​tentang kerugian C # juga.

pertama, kedua bahasa memiliki kelebihan dan kekurangan. perbedaan yang dapat Anda lakukan dalam satu bahasa yang tidak dapat dilakukan dalam bahasa lain semakin berkurang karena, untungnya, Microsoft meningkatkan kedua bahasa tersebut, dan mereka tampaknya tidak menunjukkan keberpihakan yang tidak adil terhadap kedua bahasa tersebut.

ketika C # pertama kali keluar, VB tidak memiliki komentar XML yang dapat Anda letakkan sebelum metode, yang saya sukai di C #. saya benci itu di VB.NET. tetapi saya telah melihat selama bertahun-tahun, bahwa banyak fitur yang tidak ada dalam satu bahasa ditambahkan ke bahasa lain. (tim pengembang MS yang sama mengembangkan C # dan VB, jadi masuk akal jika fiturnya menjadi sangat mirip.)

tetapi Anda menanyakan apa yang dimiliki C # sedangkan VB tidak. inilah beberapa yang dapat saya pikirkan segera:

1: C # lebih ringkas dan tidak perlu mengetik .. dalam BANYAK cara! Saya bahkan pernah melihat kebodohan berbicara ketika klaim sebaliknya dibuat, bahwa VB menghemat pengetikan. tapi tolong dengarkan orang-orang yang memberi tahu Anda bahwa mereka menggunakan kedua bahasa tersebut, dan keduanya tidak jarang digunakan. saya menggunakan C # danVB, C # di rumah karena saya menyukainya (dan ketika saya bekerja dengan C # di tempat kerja), dan pekerjaan terbaru saya meminta agar saya menggunakan VB dan bukan C #. jadi saya semakin sering menggunakan VB sekarang (sekitar 10 bulan sekarang), tetapi dalam kesaksian pribadi saya, saya lebih suka C #, dan dalam hal pengetikan sebenarnya, VB jauh lebih banyak mengetik. satu contoh yang pernah saya baca di mana seseorang benar-benar mencoba mengatakan VB lebih ringkas, memberikan contoh 'with ...' dengan variabel panjang di dalam, jadi di VB, Anda bisa menggunakan '.property'. ini adalah kebodohan dalam mengklaim bahwa VB membutuhkan lebih sedikit pengetikan. Ada beberapa hal (dan bukan hanya contoh ini) di mana VB lebih pendek, tetapi lebih banyak kali ketika C # lebih ringkas, dalam praktik nyata.

tetapi alasan terbesar saya percaya C # lebih ringkas, adalah pernyataan VB "IF / THEN". jika pernyataan umum. di C # tidak ada kata 'lalu' untuk diketik! :) juga semua pernyataan 'end ...' membutuhkan pengetikan yang di c #, biasanya hanya satu tanda kurung tutup '}'. Saya telah membaca bahwa beberapa orang mengklaim ini lebih verboseness di VB.NET adalah keuntungan untuk VB karena beberapa pernyataan / simbol blok penutup dapat bersarang dan segera berakhir di samping satu sama lain, tetapi saya sangat tidak setuju. seseorang hampir selalu dapat menulis program dengan lebih baik baik dalam C # atau VB daripada pemrogram lain karena revisi kode berikutnya dapat dirancang lebih baik. ini berlaku untuk 'banyak kurung kurawal tutup membingungkan di C #' ditambah jika blok bersarang semua jenis yang sama seperti beberapa IF bersarang maka VB menderita masalah yang sama seperti di C #. ini tidak ada keuntungan di VB. situasi ini persisnya mengapa saya suka berkomentar tentang apa simbol penutup atau pernyataan penutup saya dalam kedua bahasa tersebut. ya, ini lebih bertele-tele untuk dilakukan, tetapi dalam kedua bahasa, Anda memiliki opsi untuk menjelaskan, yang penting dalam kasus spesifik situasional berbasis penilaian. saya pikir kejelasan kode cukup penting.

2: VB tidak memiliki komentar multi-baris. ketika saya bekerja dengan VB saya tidak keberatan. lalu saya beralih ke beberapa bahasa gaya C. sekarang saya kembali kebanyakan menggunakan VB.NET di tempat kerja, dan saya merindukan mereka. itu hanya sesuatu yang Anda anggap nyaman, dan kemudian harus hilang. :(

3: VB's 'andalso' dan 'orelse' agak menjengkelkan untuk mengetik semua itu ketika di C # hanya '&&' dan '||'. sekali lagi, kurangi mengetik. ini tidak jarang dalam kode saya di VB dan C #. jika ada, untuk fungsionalitas, 'OR' vs 'OrElse' biasanya tidak masalah kecuali 'OrElse' lebih cepat untuk komputer, jadi jika programmer hanya menggunakan 'Or' dan 'And' di VB, maka kode yang dihasilkan kurang optimal untuk seseorang yang menyukai kejelasan kode. 'Atau' jauh lebih mudah untuk dibaca daripada 'OrElse'.

4: lebih banyak fleksibilitas dalam penempatan kode di C #. ketika sebuah baris panjang dan Anda ingin membungkusnya di baris berikutnya, saya benci VB.NET 'mengontrol' menyesuaikan kembali kode saya. C # melakukannya sedikit, tetapi saya merasa lebih berguna di C #, di mana di VB, itu jauh lebih mengontrol. tetapi ini lebih merupakan VB.NET IDE vs C # IDE daripada bahasa itu sendiri. tetapi saya tidak tahu apakah Anda menginginkan keduanya atau murni fitur bahasa tanpa perbedaan IDE.

5: satu yang sangat saya rindukan hanyalah membuat blok kode baru di C #, saya mungkin memiliki banyak hal yang terjadi dalam sebuah metode dan saya ingin mendeklarasikan variabel dalam blok kode yang sangat kecil tetapi tidak memiliki variabel yang dideklarasikan di luar blok itu di seluruh metode. di C #, kita bisa membuat blok baru dengan '{' dan mengakhirinya dengan '}'. VB tidak memiliki fitur seperti itu, tetapi kecocokan terdekatnya adalah blok 'If True Then' dan 'End If' tanpa syarat. (perhatikan 2 karakter C # vs 18 karakter yang setara VB.NET lagi ... lagi ketikan VB.)

6: operator kenaikan dan penurunan diri: ++ dan - seperti dalam myVariable++atau ++myVariableatau versi pengurangan yang setara. ini sangat berguna ... terkadang. berikut adalah contoh kode aktual ketika saya sangat merindukan C #:

// C#:
while (txt.Length > x)
{
    thisChar = txt[x];
    if (charsAllowedWithoutLimit.Contains(thisChar)) { ++x; }
    else if (allowLettersWithoutLimit && char.IsLetter(thisChar)) { ++x; }
    else if ((x2 = charsAllowedWithLimit.IndexOf(thisChar)) >= 0)
    {
        ++x; if (++usedCountA[x2] > charAllowedLimit[x2]) { break; }
    }
    else { break; }
}

' VB.NET:
While (txt.Length > x)
    thisChar = txt(x)
    If (charsAllowedWithoutLimit.Contains(thisChar)) Then
        x += 1
    ElseIf (allowLettersWithoutLimit AndAlso Char.IsLetter(thisChar)) Then
        x += 1
    Else
        x2 = charsAllowedWithLimit.IndexOf(thisChar)
        If (x2 >= 0) Then
            x += 1
            usedCountA(x2) += 1S
            If usedCountA(x2) > charAllowedLimit(x2) Then Exit While
        Else
            Exit While
        End If
    End If
End While

Dan hanya untuk memberikan contoh yang SANGAT bagus di mana aturan C #, ini lebih banyak kode yang saya tulis secara pribadi baru-baru ini:

// C#
public static bool IsNotWithin(this Byte   v, Byte   v1, Byte   v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this SByte  v, SByte  v1, SByte  v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Int16  v, Int16  v1, Int16  v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Int32  v, Int32  v1, Int32  v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Int64  v, Int64  v1, Int64  v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this UInt16 v, UInt16 v1, UInt16 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this UInt32 v, UInt32 v1, UInt32 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this UInt64 v, UInt64 v1, UInt64 v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }
public static bool IsNotWithin(this Decimal v, Decimal v1, Decimal v2) { return (v1 > v && v < v2) || (v2 < v && v > v1); }

public static bool IsWithin(this Byte   v, Byte   v1, Byte   v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this SByte  v, SByte  v1, SByte  v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Int16  v, Int16  v1, Int16  v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Int32  v, Int32  v1, Int32  v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Int64  v, Int64  v1, Int64  v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this UInt16 v, UInt16 v1, UInt16 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this UInt32 v, UInt32 v1, UInt32 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this UInt64 v, UInt64 v1, UInt64 v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }
public static bool IsWithin(this Decimal v, Decimal v1, Decimal v2) { return (v1 <= v && v <= v2) || (v2 <= v && v <= v1); }

' And the VB equivalent is a mess! Here goes:
<Extension()>
Public Function IsNotWithin(v As Byte, value1 As Byte, value2 As Byte) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

<Extension()>
Public Function IsNotWithin(v As SByte, value1 As SByte, value2 As SByte) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

<Extension()>
Public Function IsNotWithin(v As Int16, value1 As Int16, value2 As Int16) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

' the % suffix means 'As Integer' in VB.
<Extension()>
Public Function IsNotWithin(v%, value1%, value2%) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

' the & suffix means 'As Long' in VB.
<Extension()>
Public Function IsNotWithin(v&, value1&, value2&) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

<Extension()>
Public Function IsNotWithin(v As UInt16, value1 As UInt16, value2 As UInt16) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

<Extension()>
Public Function IsNotWithin(v As UInt32, value1 As UInt32, value2 As UInt32) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

<Extension()>
Public Function IsNotWithin(v As UInt64, value1 As UInt64, value2 As UInt64) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

' the @ suffix means 'As Decimal' in VB.
<Extension()>
Public Function IsNotWithin(v@, value1@, value2@) As Boolean
    Return (value1 > v AndAlso v < value2) OrElse (value2 < v AndAlso v > value1)
End Function

<Extension()>
Public Function IsWithin(v As Byte, value1 As Byte, value2 As Byte) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

<Extension()>
Public Function IsWithin(v As SByte, value1 As SByte, value2 As SByte) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

<Extension()>
Public Function IsWithin(v As Int16, value1 As Int16, value2 As Int16) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

' the % suffix means 'As Integer' in VB.
<Extension()>
Public Function IsWithin(v%, value1%, value2%) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

' the & suffix means 'As Long' in VB.
<Extension()>
Public Function IsWithin(v&, value1&, value2&) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

<Extension()>
Public Function IsWithin(v As UInt16, value1 As UInt16, value2 As UInt16) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

<Extension()>
Public Function IsWithin(v As UInt32, value1 As UInt32, value2 As UInt32) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

<Extension()>
Public Function IsWithin(v As UInt64, value1 As UInt64, value2 As UInt64) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

' the @ suffix means 'As Decimal' in VB.
<Extension()>
Public Function IsWithin(v@, value1@, value2@) As Boolean
    Return (value1 <= v AndAlso v <= value2) OrElse (value2 <= v AndAlso v <= value1)
End Function

Mungkin ini adalah bukti bahwa C # lebih ringkas. Tetapi tidak semua programmer menyukai keringkasan. Beberapa lebih suka membaca "jika a <b maka ..." karena itu lebih alami untuk bahasa manusia mereka. Dan itu bagus. Preferensi baik-baik saja. Bagi saya, usaha tangan adalah faktor yang saya nilai, dan saya pikir siapa pun dapat terbiasa berpikir dalam simbol apa pun yang mereka sukai, karena "jika" dan "maka" adalah simbol alfabet, dan pernyataan "jika (kondisi);" C #; sintaks juga simbol. satu lebih dekat dengan sintaks non-programmer daripada yang lain. Saya lebih suka yang ringkas.

Saya juga berpikir perlu menggunakan 'c' setelah literal karakter di VB untuk membuatnya menjadi karakter literal daripada string itu mengganggu. Saya lebih suka keringkasan C # dengan hal itu. ketika suatu metode membutuhkan karakter literal, Anda perlu memberikan karakter bukan string dengan panjang satu karakter, jadi terkadang Anda terpaksa menggunakan ":"cdi VB sementara di C # itu ':'. Saya pikir ini adalah pilih-pilih.

Agar adil, saya akan mengatakan ada keuntungan yang ingin VB seperti tidak harus menempatkan tanda kurung kosong setelah pemanggilan metode, seperti Dim nameUpper$ = name.ToUpperInvariantdi mana C # membutuhkan kurung kosong: string nameUpper = name.ToUpperInvariant(). atau dua kali lipat seperti pemangkasan juga: Dim nameUpper$ = name.Trim.ToUpperInvariantvs string nameUpper = name.Trim().ToUpperInvariant(). Saya suka penggunaan singkat VB tentang bagaimana saya baru saja menggunakan di $atas untuk meredupkannya 'As String' di mana C # tidak memiliki pintasan itu. VB memiliki shortcut tersebut untuk tipe String, Integer, Long, Decimal, Single, dan Double, tetapi kekurangannya adalah kurang jelas, jadi saya menggunakannya dengan hati-hati. Namun demikian, saya lebih suka kode yang ringkas.

Nah, itu hanya beberapa thots dari programmer berpengalaman ini, dan seperti yang saya pertimbangkan, ini adalah 'testimoni' pemrograman saya tentang C # vs VB. Keduanya adalah bahasa yang bagus, menurut saya. tapi ya, saya masih lebih suka C #.

ps Karena saya berencana membuat program untuk sebagian besar hidup saya, saya bahkan belajar kembali mengetik menggunakan keyboard yang paling efisien: keyboard Dvorak, yang membutuhkan sekitar 1/3 upaya untuk mengetik bahasa Inggris daripada menggunakan keyboard Qwerty. lihat itu. mungkin Anda mungkin ingin beralih juga. ;) membuat pengetikan saya 67% lebih mudah! :) Saya mendorong siapa pun untuk berpikir di luar kotak dan mengevaluasi efisiensi yang lebih baik dalam pekerjaan Anda. Tata Letak Keyboard Sederhana Dvorak dan C # telah melakukan ini untuk saya. :)

PSS i akan membandingkan Dvorak dan C # dengan metrik yang bertentangan dengan tata letak keyboard Qwerty dan VB dengan pengukuran Empiris. Dvorak, metrik, dan C # hanya 'bersih'. TAPI VB tidak terlalu jauh di belakang. Tapi itu menderita karena harus kompatibel dengan kode VB6 lama dan kode pra .NET, seperti 'Atau' vs 'OrElse', dan 'IIF ()'.

Saya menyelesaikannya dengan hati-hati. Harap lebih bijaksana mendengarkan orang yang tidak benar-benar tahu apa yang mereka bicarakan. Setengah dari semua kontra terhadap VB dan C # tidakmasalah apa pun lagi, dan orang-orang masih memposting tentang mereka yang tidak mengetahui tentang kerugian apa yang sebenarnya masih ada dalam bahasa tersebut. Contoh terbaik yang dapat saya pikirkan adalah komentar XML untuk metode yang menggunakan tanda kutip tiga di VB atau simbol komentar garis miring tiga di C #. Tetapi tolong pahami sendiri apakah seseorang berbicara dari ketidaktahuan, atau dari pengalaman. Kesaksian pribadi berarti mereka tahu dari pengalaman nyata mereka. Dan setelah seseorang memiliki banyak pengalaman di dalamnya, maka bersemangatlah telinga Anda. Saya memiliki lebih dari 10 tahun pengalaman di C # dan VB. Dan intinya begini: keduanya adalah bahasa (sangat) bagus. Dan sebagian besar perbedaannya, Anda dapat langsung melihat dalam 5 menit setelah membaca kode. Tapi ya, fitur lain mungkin butuh waktu bertahun-tahun untuk menemukan cacatnya. Dan satu cacat yang saya sadari (di C #), saya bisa ' Saya bahkan tidak memikirkan situasi kehidupan nyata yang akan berguna. Jadi mungkin itu bukan cacat sama sekali.

Selamat membuat kode!


Saya menghargai semua detailnya, tetapi contoh Anda tidak menggunakan sensitivitas / ketidakpekaan huruf besar (sejauh yang saya tahu) untuk menunjukkan mengapa C # entah bagaimana "lebih baik".
Todd Main

Saya mencoba menjawab pertanyaan kedua dengan contoh langsung.
Venkat

@Toddain, benar. Dan contoh saya tidak menggunakan sensitivitas huruf untuk menunjukkan mengapa C # lebih baik karena pertanyaannya tidak menanyakan mengapa sensitivitas huruf membuatnya lebih baik. Selain itu, saya yakin fitur ini berbicara sendiri. Dan saya percaya logikanya adalah enuf dasar bahwa kebanyakan orang dapat menyimpulkannya sendiri. Tetapi jika seseorang bertanya, dengan senang hati saya akan membantu menjelaskannya. Tapi itu, teman saya, menurut saya, adalah pertanyaan yang berbeda. ;)
Shawn Kovac

Sebenarnya, itu adalah salah satu dari dua pertanyaan yang diajukan di postingan asli. Itu tidak terbukti dengan sendirinya, itulah sebabnya saya bertanya. Tapi jangan khawatir untuk tidak menjawab pertanyaan itu.
Todd Main

@Toddd, saya mengerti maksud Anda. memang poin yang sangat adil. :) Terima kasih telah membuka mata saya untuk ini. :)
Shawn Kovac

0

VB.NET peka huruf besar kecil.

Contoh:

1.

Dim a As Integer
Dim A as Integer

2.

Sub b()
    'Some statement(s) here
End Sub
Sub B()
    'Some statement(s) here
End Sub

3.

Function c() As Integer
    'Some statement(s) here
End Function
Function C() As Integer
    'Some statement(s) here
End Function

Semua kode ini akan memunculkan KESALAHAN WAKTU SELESAI .

Untuk contoh pertama, kesalahan akan ditampilkan, mengatakan "Variabel lokal 'A' sudah dideklarasikan di blok saat ini.".

Sedangkan untuk contoh ke-2 dan ke-3, akan ditampilkan error yang mengatakan "'Public Sub b ()' memiliki banyak definisi dengan tanda tangan yang identik." dan "'Public Function c () As Integer' memiliki beberapa definisi dengan tanda tangan yang identik."

Dari kesalahan ini, perhatikan bahwa kesalahan dilemparkan pada posisi yang berbeda untuk variabel dan prosedur / fungsi. Untuk variabel, kesalahan dilemparkan pada deklarasi ke-2 sedangkan untuk prosedur / fungsi dilempar ke deklarasi / definisi pertama dari kode identik.

Seperti yang dikatakan oleh pengguna dalam komentar di suatu tempat di atas, kode VB.NET terus diperiksa dan / atau dikoreksi di latar belakang; Anda dapat melihat kesalahan ini di jendela "Daftar Kesalahan" di VS IDE. Dan karena ini adalah ERROR dan BUKAN PERINGATAN , kode tidak akan dikompilasi sampai kesalahan teratasi.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.