Perbandingan string tidak peka huruf besar / kecil di LINQ-to-SQL

Saya telah membaca bahwa tidak bijaksana menggunakan ToUpper dan ToLower untuk melakukan perbandingan string yang tidak peka huruf besar / kecil, tetapi saya tidak melihat alternatif lain dalam hal LINQ-to-SQL. Argumen ignoreCase dan CompareOptions dari String.Compare diabaikan oleh LINQ-to-SQL (jika Anda menggunakan database case-sensitive, Anda mendapatkan perbandingan case-sensitive bahkan jika Anda meminta perbandingan case-sensitive). Apakah ToLower atau ToUpper merupakan opsi terbaik di sini? Apakah yang satu lebih baik dari yang lain? Saya pikir saya pernah membaca bahwa ToUpper lebih baik, tetapi saya tidak tahu apakah itu berlaku di sini. (Saya melakukan banyak tinjauan kode dan semua orang menggunakan ToLower.)

Dim s = From row In context.Table Where String.Compare(row.Name, "test", StringComparison.InvariantCultureIgnoreCase) = 0

Ini diterjemahkan menjadi kueri SQL yang hanya membandingkan row.Name dengan "test" dan tidak akan mengembalikan "Test" dan "TEST" pada database case-sensitive.

Seperti yang Anda katakan, ada beberapa perbedaan penting antara ToUpper dan ToLower, dan hanya satu yang dapat diandalkan akurat saat Anda mencoba melakukan pemeriksaan persamaan tidak peka huruf besar / kecil.

Idealnya, cara terbaik untuk melakukan pemeriksaan persamaan tidak peka huruf besar / kecil adalah :

String.Equals(row.Name, "test", StringComparison.OrdinalIgnoreCase)

CATATAN, NAMUN bahwa ini tidak berfungsi dalam kasus ini! Oleh karena itu kita terjebak dengan ToUpperatau ToLower.

Perhatikan Ordinal IgnoreCase untuk membuatnya aman bagi keamanan. Tapi sebenarnya jenis pemeriksaan sensitif huruf besar / kecil yang Anda gunakan bergantung pada tujuan Anda. Namun secara umum, gunakan Sama untuk pemeriksaan kesetaraan dan Bandingkan saat Anda menyortir, lalu pilih Perbandingan String yang tepat untuk pekerjaan itu.

Michael Kaplan (otoritas yang diakui pada budaya dan penanganan karakter seperti ini) memiliki posting yang relevan di ToUpper vs. ToLower:

• http://www.siao2.com/2007/10/01/5218976.aspx
• http://www.siao2.com/2005/03/10/391564.aspx

Dia mengatakan "String.ToUpper - Gunakan ToUpper daripada ToLower, dan tentukan InvariantCulture untuk mengambil aturan casing OS "

Saya digunakan System.Data.Linq.SqlClient.SqlMethods.Like(row.Name, "test") dalam permintaan saya.

Ini melakukan perbandingan tidak peka huruf besar / kecil.

Saya mencoba ini menggunakan ekspresi Lambda, dan berhasil.

List<MyList>.Any (x => (String.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase)) && (x.Type == qbType) );

Jika Anda meneruskan string yang case-insensitive ke LINQ-to-SQL, string tersebut akan diteruskan ke SQL tanpa perubahan dan perbandingan akan terjadi di database. Jika Anda ingin melakukan perbandingan string tidak peka huruf besar / kecil dalam database, yang perlu Anda lakukan hanyalah membuat ekspresi lambda yang melakukan perbandingan dan penyedia LINQ-to-SQL akan menerjemahkan ekspresi itu ke dalam kueri SQL dengan string Anda utuh.

Misalnya kueri LINQ ini:

from user in Users
where user.Email == "foo@bar.com"
select user

diterjemahkan ke SQL berikut oleh penyedia LINQ-to-SQL:

SELECT [t0].[Email]
FROM [User] AS [t0]
WHERE [t0].[Email] = @p0
-- note that "@p0" is defined as nvarchar(11)
-- and is passed my value of "foo@bar.com"

Seperti yang Anda lihat, parameter string akan dibandingkan dalam SQL yang berarti segala sesuatunya harus berfungsi seperti yang Anda harapkan.

Untuk melakukan query Linq ke Sql case sensitive mendeklarasikan field 'string' menjadi case sensitive dengan menentukan tipe data server dengan menggunakan salah satu dari berikut ini;

varchar(4000) COLLATE SQL_Latin1_General_CP1_CS_AS 

atau

nvarchar(Max) COLLATE SQL_Latin1_General_CP1_CS_AS

Catatan: 'CS' pada jenis pemeriksaan di atas berarti 'Peka Huruf Besar-Kecil'.

Ini dapat dimasukkan di bidang "Jenis Data Server" saat melihat properti menggunakan Visual Studio DBML Designer.

Untuk lebih jelasnya lihat http://yourdotnetdesignteam.blogspot.com/2010/06/case-sensitive-linq-to-sql-queries.html

where row.name.StartsWith(q, true, System.Globalization.CultureInfo.CurrentCulture)

Pendekatan 2-tahap berikut berfungsi untuk saya (VS2010, ASP.NET MVC3, SQL Server 2008, Linq ke SQL):

result = entRepos.FindAllEntities()
    .Where(e => e.EntitySearchText.Contains(item));

if (caseSensitive)
{
    result = result
        .Where(e => e.EntitySearchText.IndexOf(item, System.StringComparison.CurrentCulture) >= 0);
}

Terkadang nilai yang disimpan dalam Database bisa berisi spasi sehingga menjalankan ini bisa gagal

String.Equals(row.Name, "test", StringComparison.OrdinalIgnoreCase)

Solusi untuk masalah ini adalah dengan menghapus spasi kemudian mengubah case-nya kemudian pilih seperti ini

 return db.UsersTBs.Where(x => x.title.ToString().ToLower().Replace(" ",string.Empty).Equals(customname.ToLower())).FirstOrDefault();

Perhatikan dalam kasus ini

customname adalah nilai yang sesuai dengan nilai Database

UsersTBs adalah kelas

judul adalah kolom Database

Ingatlah bahwa ada perbedaan antara apakah kueri berfungsi dan apakah berfungsi secara efisien ! Pernyataan LINQ akan diubah menjadi T-SQL jika target pernyataan tersebut adalah SQL Server, jadi Anda perlu memikirkan tentang T-SQL yang akan diproduksi.

Menggunakan String.Equals kemungkinan besar (saya menebak) akan membawa kembali semua baris dari SQL Server dan kemudian melakukan perbandingan dalam .NET, karena ini adalah ekspresi .NET yang tidak dapat diterjemahkan ke dalam T-SQL.

Dengan kata lain, menggunakan ekspresi akan meningkatkan akses data Anda dan menghilangkan kemampuan Anda untuk menggunakan indeks. Ini akan berfungsi pada tabel kecil dan Anda tidak akan melihat perbedaannya. Di atas meja besar itu bisa berkinerja sangat buruk.

Itulah salah satu masalah yang ada dengan LINQ; orang tidak lagi memikirkan bagaimana pernyataan yang mereka tulis akan dipenuhi.

Dalam kasus ini tidak ada cara untuk melakukan apa yang Anda inginkan tanpa menggunakan ekspresi - bahkan di T-SQL. Oleh karena itu, Anda mungkin tidak dapat melakukan ini dengan lebih efisien. Bahkan jawaban T-SQL yang diberikan di atas (menggunakan variabel dengan pemeriksaan) kemungkinan besar akan mengakibatkan indeks diabaikan, tetapi jika itu adalah tabel besar maka ada baiknya menjalankan pernyataan dan melihat rencana eksekusi untuk melihat apakah indeks digunakan .