Dün yayında olan bir PHP projesinde çeşitli değişiklikler yapmak durumunda kaldım. Test etme şansım olmadığından dosyanın bir kopyasını sunucuya atarak sunucu üzerinde test etmeye çalıştım. Gönderdiğim dosyayı çalıştırmayı denediğimde bomboş bir ekranla karşılaştım. Güvenlik nedeniyle sunucu, hata mesajlarını ekrana basmayacak şekilde ayarlanmıştı. Hata kayıtları da benim yetkim olmayan bir yerde duruyordu. Bir şekilde hatanın nerede olduğunu bulmam gerekiyordu. Çok fazla değişiklik yaptığım için eski dosya ve yeni dosya arasında bir karşılaştırma yapmak uzun sürecekti. Bir kaç kontrol yapmaya karar verdim.

İlk olarak söz dizimi kontrolü yaparak dosyanın PHP tarafından işlenebildiğinden emin olmak istedim. Bunun için PHP’yi komut satırından “-l” parametresi ile çalıştırıp ikinci parametre olarak dosyanın ismini verebilirsiniz. Eğer PHP klasörünüz PATH değişkeninde tanımlandıysa dosyanızın olduğu klasörde komut satırı açarak php -l dosyaismi.php şeklinde söz dizimi kontrolü gerçekleştirebilirsiniz. PATH değişkeninde tanımlı değilse php.exe’nin tam yolunu girmeniz gerekebilir (Örneğin: c:\php\php.exe -l dosyaismi.php)

Bu komut PHP dosyanızı kontrol edecek, bir hata bulamazsa sonlanacak ya da bulduğu ilk hatada hatanın olduğu satır numarasını ekrana basarak sonlanacaktır. İlgili hatayı düzelttikten sonra komutu tekrar çalıştırarak, dosyayı tekrar kontrol edebilirsiniz. Bu şekilde hiç söz dizimi hatası kalmayana kadar kodu tekrar tekrar çalıştırarak dosyanızı hatalardan arındırabilirsiniz.

Bu şekilde problemimi giderip dosyayı sunucuya tekrar yükledim. Problemim giderilmişti.

ASP.NET ile uygulama geliştirirken çok ilginç bir sorunla karşılaştım. Biraz uğraştıktan sonra sorunu çözdüm. Şansıma çok büyük bir proje değildi ve yine şansıma küçük bir değişiklik yaptığım sırada karşıma çıktı. Bu yüzden problemi çok daha kolay tanımlayabildim ve bu da çözüme daha kolay ulaşmamı sağladı.

Problem derleme sırasında karşınıza çıkmıyor. Proje sorunsuz bir şekilde yapılandırılıyor fakat problemin olduğu web sayfasını açmak istediğinizde ilk satırda belirsiz eşleşme (Ambiguous match) bulunduğu ile ilgili bir hata mesajı alıyorsunuz ve sayfa açılmıyor. Aşağıdaki ekran görüntüsüne benzer bir görüntü ortaya çıkıyor.

Bir süre webde araştırınca sorunun neden oluştuğunu, nasıl çözüleceğini burada buldum. Temel olarak problem, web sayfasında tanımlanmış bir kontrol ile aynı isme sahip bir değişken tanımlandığında ortaya çıkıyor. C# büyük/küçük harf duyarlı bir dil olsa da nedense bu durumda düzgün çalışmıyor ve hata üretiyor. Yani sayfanızda “Metin” isimli bir kontrol bulunuyorsa “metin” isimli bir değişken kullanmamanız gerekiyor.

Karşımıza açıklayıcı bir hata mesajı çıkmadığı için bu davranışın bir bug olduğunu düşünüyorum. İşin ilginç yanı konuyla ilgili bulduğum makale 2006 yılına ait, yani en az 5 senedir bu problem var ve Microsoft tarafından konu ile ilgili bir geliştirme/açıklama/düzeltme söz konusu değil…

jQuery kullandığım bir projede, seçim kutusu(select elemanı) seçeneklerini(option) değişkende saklayarak, istediğim zaman istediğim kadar kullanmayı planladım. Daha iyi anlaşılabilmesi için ufak bir kod örneği vereyim;

  var secenekler = '<option value="34">İstanbul</option><option value="6">Ankara</option><option value="35">İzmir</option>';
  $('#Baslangic').html(secenekler);
  $('#Varis').html(secenekler);

Buraya kadar bir sorun ortaya çıkmadı. Ne zaman ki, bu şekilde doldurduğum seçim kutularında bir elemanı seçili hale getirmeye çalıştım, işte o zaman Internet Explorer 6′da (IE6) garip bir hata mesajı ile karşılaştım: “Could not set the selected property. Unspecified error.” IE7, IE8, Firefox, Opera, Chrome ve Safari’de sorunsuz bir şekilde çalışırken, IE6 bu şekilde, anlaşılmaz bir hata mesajı ile beni çıkmaza soktu. Seçim yapmak için kullandığım kod öbeğini de eklersek kod örneğimiz şu hale geliyor;

  var secenekler = '<option value="34">İstanbul</option><option value="6">Ankara</option><option value="35">İzmir</option>';
  $('#Baslangic').html(secenekler).val(34);
  $('#Varis').html(secenekler).val(35);

Hata mesajının ilk bölümü, kısmen problemin neden kaynaklandığını açıklasa da ikinci bölümdeki “Belirsiz hata” ibaresi direkt olarak bir çözüme yönlenmemi engelledi. Internetlerde yaptığım ufak bir araştırma ile bu sayfada probleme ve olası bir çözüme ulaştım. Problem IE6′da DOM’un yeteri kadar hızlı çalışamamasından kaynaklanıyormuş. DOM ağacını zamanında hazırlayamadığı için, seçim yapmak istediğimizde seçim kutusunda ilgili elemanı bulamıyor ve ilgili hata mesajını ekrana basıyor.

Problemi çözmek için bir çok alternatif yöntem uygulayabilirsiniz. Problem ile ilgili bilgi bulduğum sayfadaki çözüm, try/catch bloğunu iş akışının bir parçası olarak kullandığından benim gözümde ideal bir çözüm değil. Tabi tercih size kalmış. Benzer bir durum için benim önerebileceğim çözüm şu olabilir;

  var secenekler = '<option value="34">İstanbul</option><option value="6">Ankara</option><option value="35">İzmir</option>';
  var $Baslangic = $('#Baslangic').html(secenekler);
  var $Varis = $('#Varis').html(secenekler);
  if($.browser.msie && $.browser.version === "6.0") {
    setTimeout(function() {
      $Baslangic.val(34);
      $Bitis.val(35);
    }, 1);
  }
  else {
    $Baslangic.val(34);
    $Bitis.val(35);
  }

İşin püf noktası, tarayıcı IE6 ise, seçim işlemlerini 1 milisaniyelik bir gecikme ile gerçekleştirip, bu ufacık gecikme ile DOM’a kendini toparyalabilmesi için zaman tanımak.

Alternatif olarak, imkanınız varsa, seçeneklerden seçili olmasını istediğiniz elemana da selected=”selected” özelliğini atayarak bu hatadan kaçınabilirsiniz. Bu örnekte aynı seçenekleri birden çok kez kullanacağım için ve varsayılan olarak belirli bir tanesini seçili durumda oluşturamayacağım için bu şekilde bir çözüm yoluna gittim.

PHP ile bu işi nasıl yapabileceğimizi daha önce anlatmıştım. C# ile geliştirdiğimiz bir uygulamada da gerekli olunca biraz araştırdım. PHP ile olan deneyimlerimden yola çıkarak ihtiyaç listesi çıkarttım ve bu ihtiyaçlar doğrultusunda biraz araştırma yaptım. Bu araştırmalardan bir tanesi HTML etiketlerinin temizlenmesi konusuydu ki ondan da bahsetmiştim. Geriye çentikli karakterlerin (ğ,ü,ş,ö,ç, ì, é vb.) çentiksiz hallerine ulaşmak gibi bir problem kalmıştı. Problemin çözümüne burada ulaştım.

PHP deneyimlerim ile ulaştığım metotları birleştirince aşağıdaki kod öbeği ortaya çıktı. Önce bir örnek vererek nasıl kullanacağınızı göstereyim;

string baslik = "Öğümce yolları çakıl taşları ile dolmuş - Test başlığı";
MakeSlug(baslik); // "ogumce-yollari-cakil-taslari-ile-dolmus-test-basligi" değerini döndürecektir.

Bu işi yapan kod öbeği:

public string MakeSlug(string input)
{
  input = input.ToLower(new CultureInfo("tr-TR"));
  input = StripTags(input);
  input = RemoveAccents(input);
  input = Regex.Replace(input, "&.+?;", "");
  input = Regex.Replace(input, "[^.a-z0-9 _-]", "");
  input = Regex.Replace(input, @"\.|\s+", "-");
  input = Regex.Replace(input, "-+", "-");
  input = input.Trim('-');
  return input;
}

public string RemoveAccents(string input)
{
  string normalized = input.Replace('ı', 'i').Normalize(NormalizationForm.FormKD);
  char[] array = new char[input.Length];
  int arrayIndex = 0;
  foreach (char c in normalized)
  {
    if (char.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
    {
      array[arrayIndex] = c;
      arrayIndex++;
    }
  }
  return new string(array, 0, arrayIndex);
}

public string StripTags(string input)
{
  char[] array = new char[input.Length];
  int arrayIndex = 0;
  bool inside = false;

  for (int i = 0; i < input.Length; i++)
  {
    char let = input[i];
    if (let == '<')
    {
      inside = true;
      continue;
    }
    if (let == '>')
    {
      inside = false;
      continue;
    }
    if (!inside)
    {
      array[arrayIndex] = let;
      arrayIndex++;
    }
  }
  return new string(array, 0, arrayIndex);
}

Daha önce bahsettiğim .NET için HTML etiketleri temizleme metodunu JavaScript uygulamalarında kullanmak için düzenledim. Şöyle buyrun:

function StripTags(input)
{
  var array = [];
  var inside = false;

  for (i = 0; i < input.length; i++)
  {
    var let = input.charAt(i);
    if (let == '<')
    {
      inside = true;
      continue;
    }
    if (let == '>')
    {
      inside = false;
      continue;
    }
    if (!inside)
      array.push(let);
  }
  return array.join('');
}

Bir metnin içindeki HTML etiketlerini temizlemek için çözüm yolları ararken, çok ilginç bir çözüm ile karşılaştım. Bu ve benzeri durumlarda genellikle ilk olarak, problemi kendim nasıl çözerim diye düşünürüm. İlk aklıma gelen, düzgün yapılandırılmış bir düzenli ifade (regular expression) ile metnin içindeki tüm HTML etiketlerini temizlemek oldu. Uygulamaya geçmeden önce bir de internette araştırayım dedim ve burada probleme çok ilginç bir yönden yaklaşan bir çözüm buldum. Makalede benim aklıma da gelen düzenli ifadeler ile karşılaştırma da yapılmış ve makalede görebileceğiniz gibi bu yöntem çok daha hızlı çalışıyor. Bunun en önemli sebebi de çok yalın bir mantık kullanılmış olması.

Makalede yazılanları tekrar etmek istemiyorum. Metodun C# ve VB.NET sürümlerini aşağıya ekliyorum.

Metodun C# sürümü

public string StripTags(string input)
{
  char[] charArray = new char[input.Length];
  int arrayIndex = 0;
  bool inside = false;
  for (int i = 0; i < input.Length; i++)
  {
    char tmp = input[i];
    if (tmp == '<')
    {
      inside = true;
      continue;
    }
    if (tmp == '>')
    {
      inside = false;
      continue;
    }
    if (!inside)
    {
      charArray[arrayIndex] = tmp;
      arrayIndex++;
    }
  }
  return new string(charArray, 0, arrayIndex);
}

Metodun VB.NET sürümü

Public Function StripTags(ByVal input As String) As String
  Dim charArray As Char() = New Char(input.Length - 1) {}
  Dim arrayIndex As Integer = 0
  Dim inside As Boolean = False

  For i As Integer = 0 To input.Length - 1
    Dim tmp As Char = input(i)
    If tmp = "< "c Then
      inside = True
      Continue For
    End If
    If tmp = ">"c Then
      inside = False
      Continue For
    End If
    If Not inside Then
      charArray(arrayIndex) = tmp
      arrayIndex += 1
    End If
  Next
  Return New String(charArray, 0, arrayIndex)
End Function

Uzun zamandır, geliştirdiğim web sitelerinde, hem daha anlaşılır olması, hem de SEO açısından daha faydalı olduğu genel kanaat olduğu için, adresleri ilgili sayfanın başlığından oluşturuyorum. İlk başlarda başlığı adrese çeviren bir metot yazmıştım, fakat zaman geçtikçe bu metodun çeşitli durumlarda düzgün çalışmadığını gözledim. Bunun üzerine örnekler ve en iyi pratiklere göz atmaya başladım.

Bu konuda en başarılı bulduğum uygulama WordPress oldu. WordPress açık kaynak kodlu bir uygulama olduğundan hemen kaynak kodlarını inceleyerek bu problemin üstesinden nasıl geldiklerini inceledim ve gerekli kısımları bir araya getirdim. WordPress’i seçme sebeplerimden birisi de, uygulamanın bir çok dilde kullanılması ve ilgili metotların bu dilleri destekleyecek şekilde geliştirilmeleriydi.

Neyse lafı fazla uzatmadan kodları paylaşayım, önce bir örnek ile nasıl kullanacağınızı göstereyim:

$baslik = "Öğümce yolları çakıl taşları ile dolmuş - Test başlığı";
echo sanitize_title_with_dashes($baslik);
// "ogumce-yollari-cakil-taslari-ile-dolmus-test-basligi" çıktısını üretecektir.

Son olarak da gerekli metotlar:

/**
 * Sanitizes title, replacing whitespace with dashes.
 *
 * Limits the output to alphanumeric characters, underscore (_) and dash (-).
 * Whitespace becomes a dash.
 *
 * @since 1.2.0
 *
 * @param string $title The title to be sanitized.
 * @return string The sanitized title.
 */
function sanitize_title_with_dashes($title) {
	$title = strip_tags($title);
	// Preserve escaped octets.
	$title = preg_replace('|%([a-fA-F0-9][a-fA-F0-9])|', '---$1---', $title);
	// Remove percent signs that are not part of an octet.
	$title = str_replace('%', '', $title);
	// Restore octets.
	$title = preg_replace('|---([a-fA-F0-9][a-fA-F0-9])---|', '%$1', $title);

	$title = remove_accents($title);
	if (seems_utf8($title)) {
		if (function_exists('mb_strtolower')) {
			$title = mb_strtolower($title, 'UTF-8');
		}
		$title = utf8_uri_encode($title, 200);
	}

	$title = strtolower($title);
	$title = preg_replace('/&.+?;/', '', $title); // kill entities
	$title = str_replace('.', '-', $title);
	$title = preg_replace('/[^%a-z0-9 _-]/', '', $title);
	$title = preg_replace('/\s+/', '-', $title);
	$title = preg_replace('|-+|', '-', $title);
	$title = trim($title, '-');

	return $title;
}

/**
 * Converts all accent characters to ASCII characters.
 *
 * If there are no accent characters, then the string given is just returned.
 *
 * @since 1.2.1
 *
 * @param string $string Text that might have accent characters
 * @return string Filtered string with replaced "nice" characters.
 */
function remove_accents($string) {
	if ( !preg_match('/[\x80-\xff]/', $string) )
		return $string;

	if (seems_utf8($string)) {
		$chars = array(
		// Decompositions for Latin-1 Supplement
		chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
		chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
		chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
		chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',
		chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',
		chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',
		chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',
		chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',
		chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
		chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
		chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
		chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
		chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
		chr(195).chr(159) => 's', chr(195).chr(160) => 'a',
		chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',
		chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',
		chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',
		chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
		chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
		chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
		chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
		chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',
		chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',
		chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',
		chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',
		chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',
		chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',
		chr(195).chr(191) => 'y',
		// Decompositions for Latin Extended-A
		chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
		chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
		chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
		chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
		chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
		chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
		chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
		chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
		chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
		chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
		chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
		chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
		chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
		chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
		chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
		chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
		chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
		chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
		chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
		chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
		chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
		chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
		chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
		chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
		chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
		chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
		chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
		chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
		chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
		chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
		chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
		chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
		chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
		chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
		chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
		chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
		chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
		chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
		chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
		chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
		chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
		chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
		chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
		chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
		chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
		chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
		chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
		chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
		chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
		chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
		chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
		chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
		chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
		chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
		chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
		chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
		chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
		chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
		chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
		chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
		chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
		chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
		chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
		chr(197).chr(190) => 'z', chr(197).chr(191) => 's',
		// Euro Sign
		chr(226).chr(130).chr(172) => 'E',
		// GBP (Pound) Sign
		chr(194).chr(163) => '');

		$string = strtr($string, $chars);
	} else {
		// Assume ISO-8859-1 if not UTF-8
		$chars['in'] = chr(128).chr(131).chr(138).chr(142).chr(154).chr(158)
			.chr(159).chr(162).chr(165).chr(181).chr(192).chr(193).chr(194)
			.chr(195).chr(196).chr(197).chr(199).chr(200).chr(201).chr(202)
			.chr(203).chr(204).chr(205).chr(206).chr(207).chr(209).chr(210)
			.chr(211).chr(212).chr(213).chr(214).chr(216).chr(217).chr(218)
			.chr(219).chr(220).chr(221).chr(224).chr(225).chr(226).chr(227)
			.chr(228).chr(229).chr(231).chr(232).chr(233).chr(234).chr(235)
			.chr(236).chr(237).chr(238).chr(239).chr(241).chr(242).chr(243)
			.chr(244).chr(245).chr(246).chr(248).chr(249).chr(250).chr(251)
			.chr(252).chr(253).chr(255);

		$chars['out'] = "EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy";

		$string = strtr($string, $chars['in'], $chars['out']);
		$double_chars['in'] = array(chr(140), chr(156), chr(198), chr(208), chr(222), chr(223), chr(230), chr(240), chr(254));
		$double_chars['out'] = array('OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th');
		$string = str_replace($double_chars['in'], $double_chars['out'], $string);
	}

	return $string;
}

/**
 * Checks to see if a string is utf8 encoded.
 *
 * NOTE: This function checks for 5-Byte sequences, UTF8
 *       has Bytes Sequences with a maximum length of 4.
 *
 * @author bmorel at ssi dot fr (modified)
 * @since 1.2.1
 *
 * @param string $str The string to be checked
 * @return bool True if $str fits a UTF-8 model, false otherwise.
 */
function seems_utf8($str) {
	$length = strlen($str);
	for ($i=0; $i < $length; $i++) {
		$c = ord($str[$i]);
		if ($c < 0x80) $n = 0; # 0bbbbbbb
		elseif (($c & 0xE0) == 0xC0) $n=1; # 110bbbbb
		elseif (($c & 0xF0) == 0xE0) $n=2; # 1110bbbb
		elseif (($c & 0xF8) == 0xF0) $n=3; # 11110bbb
		elseif (($c & 0xFC) == 0xF8) $n=4; # 111110bb
		elseif (($c & 0xFE) == 0xFC) $n=5; # 1111110b
		else return false; # Does not match any model
		for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?
			if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))
				return false;
		}
	}
	return true;
}

/**
 * Encode the Unicode values to be used in the URI.
 *
 * @since 1.5.0
 *
 * @param string $utf8_string
 * @param int $length Max length of the string
 * @return string String with Unicode encoded for URI.
 */
function utf8_uri_encode( $utf8_string, $length = 0 ) {
	$unicode = '';
	$values = array();
	$num_octets = 1;
	$unicode_length = 0;

	$string_length = strlen( $utf8_string );
	for ($i = 0; $i < $string_length; $i++ ) {

		$value = ord( $utf8_string[ $i ] );

		if ( $value < 128 ) {
			if ( $length && ( $unicode_length >= $length ) )
				break;
			$unicode .= chr($value);
			$unicode_length++;
		} else {
			if ( count( $values ) == 0 ) $num_octets = ( $value < 224 ) ? 2 : 3;

			$values[] = $value;

			if ( $length && ( $unicode_length + ($num_octets * 3) ) > $length )
				break;
			if ( count( $values ) == $num_octets ) {
				if ($num_octets == 3) {
					$unicode .= '%' . dechex($values[0]) . '%' . dechex($values[1]) . '%' . dechex($values[2]);
					$unicode_length += 9;
				} else {
					$unicode .= '%' . dechex($values[0]) . '%' . dechex($values[1]);
					$unicode_length += 6;
				}

				$values = array();
				$num_octets = 1;
			}
		}
	}

	return $unicode;
}

Bugün valiDate metodunu çalışma arkadaşıma gösterirken, neden doğrulama başarılı olduğunda tarih nesnesini döndürmediğim sorusu aklıma geldi. Toplam 7 byte’lık ufak bir ekleme ile, doğrulama başarılı olduğunda JavaScript tarih nesnesi döndürecek şekilde metodu güncelledim. Bu sayede metottan dönen değeri hala if ifadesi içinde kullanabilirken, isterseniz if ifadesinden önce metottan dönen değeri bir değişkene atayarak, bu değişkeni if ifadesinde kullanabilir ve doğrulamayı geçerse değişkeni tarih nesnesi olarak kullanabilirsiniz. Hatta abartıp doğrulamadan dönen değeri direkt if ifadesi içinde değişkeninize atayarak da kullanabilirsiniz.

/*
 * valiDate
 * http://www.karalamalar.net/
 *
 * Copyright (c) 2009 İzzet Emre Erkan
 * Licensed under Creative Commons Attribution-Share Alike 3.0 Unported License
 * http://creativecommons.org/licenses/by-sa/3.0/
 *
 * Date: 2010-04-16 17:08:32 +0300 (Fri, 16 Apr 2010)
 * Revision: 7
 */
String.prototype.valiDate =
  function() {
    if(/^(0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.](19|20)[0-9]{2}$/.test(this)) {
      var v = this.replace(/[- /]/g,'.').split('.');
      var d=parseInt(v[0],10), m=parseInt(v[1],10), y=parseInt(v[2],10);
      var o = new Date(y, m - 1, d);
      return o.getDate() == d && o.getMonth() + 1 == m && o.getFullYear() == y ? o : false;
    }
    else
      return false;
  }

Metodun küçültülmüş halini (647 byte) buradan edinebilirsiniz.

Geçen gün uygulamalarımızın çalıştığı sunucunun olay kayıtlarını incelerken ASP.NET’in sürekli olarak bu hata ile karşılaştığını gördüm. Bunun neticesinde web siteleri kimi zaman cevap veremez duruma geliyordu. Internette biraz araştırma yaptığımda genelde geliştiricilerin Visual Studio’da çalışırken bu hatayla karşılaştıklarını gördüm. Bir süre çözüm aradıktan sonra bu yazıyı bulduk(Engin ile birlikte). Benim gibi bu problemle karşılaşmış ve çözüm yolu arayışındaki başka bir geliştiricinin bulduğu çözümü ben de sizlerle paylaşayım dedim.

web.config dosyanızda system.web elemanına aşağıdaki kod öbeğini ekleyerek sorundan kurtulabilirsiniz.

shadowCopyBinAssemblies özelliği şu şekilde tanımlanmış: Bir Boolean(Evet/Hayır) değeri ile uygulamanın Bin klasöründe yer alan bileşenlerinin, gölge kopyalarının (shadow copy) uygulamanın ASP.NET geçici dosyalar klasörüne kopyalanıp kopyalanmayacağını belirtir.

Umarım işinize yarar.

C# ile geliştirdiğim projelerde XML üretmem gerektiğinde, bu konuda çok becerikli olduğunu düşündüğüm XmlWriter nesnesini kullanırım. Nesneyi oluştururken aşağıdaki gibi oluştururdum;

XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);

Bilmediğim şey ise, bu şekilde nesneyi oluştururken otomatik olarak streamin başına UTF-8 tanımlayıcısı olan üç baytlık BOM karakter dizisinin ekleniyor olduğuydu. Yazmış olduğum bir servisi kullanan firmadan gelen dönüş ile, gönderdiğim XML’de BOM olduğunu ve bu yüzden XML’i düzgün işleyemediklerini öğrendim. Bunun üzerine BOM olmadan XML’i nasıl oluştururum diye araştırdım ve buradaki makaleye ulaştım.

Yapmamız gereken çok basit. Daha önce Encoding.UTF8 ile elde ettiğimiz Encoding nesnesini bu sefer yeni bir Encoding nesnesi oluşturarak hallediyoruz. Yeni Encoding nesnemizi oluştururken de encoderShouldEmitUTF8Identifier parametresini false olarak kullanıyoruz;

XmlWriter writer = new XmlTextWriter(stream, new UTF8Encoding(false));

Ben XmlWriter kullanırken bu sorunla karşılaştığımdan yazı da bu konu etrafında şekillendi. Elbette ki Encoding kullandığınız başka durumlarda da bu şekilde Encoding nesneleri oluşturabilirsiniz.