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

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?

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.

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.

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.

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 :)

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.

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 :)

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.

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

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.

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.

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

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

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!

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.