Curious Case of Code Contracts and Roslyn

CODE CONTRACTS

We have a large visual studio solution that uses Microsoft CodeContracts for run-time verification and static analysis. Code contracts is a great tool that proves there are bugs in your source code. When it is hard to deduce for the static analyzer to prove facts, you can always help by adding contract blocks in your source code. In addition to static analysis, using a contract statement such as

Contract.Requires(count > 0);

will throw an exception at the runtime. Code contracts extension includes an IL weaver engine that rewrites the Contract statements to a statement that performs the runtime check and reports an error that includes the predicate as a string:

__ContractsRuntime.Requires(count > 0, null"count > 0");

There are many other aspects of the Microsoft Code Contracts that your solution can benefit and they have an extensive documentation.

ROSLYN

On the other hand we have Roslyn installed as the default compiler service within Visual Studio 2013. Rest all other pros, navigating within Visual Studio is many times faster now with Roslyn.

THE PROBLEM

… is that when you have a method which has dynamic local variables, code contracts rewriter (ccrewrite.exe) throws an internal exception which leads to an error message similar to:

1> There were errors reported in {0}'s metadata.
1> Unknown custom metadata item kind: 5

Upon investigating one can find out that Code Contracts project is snail-speed with its updates and it takes time to catch the changes. In this case, code contracts is lagging behind Roslyn in terms of PDB (program database) reading and writing.

After searching for the string “Unknown custom metadata item kind:”, we arrive at the method ReadCustomMetadata in PdbFunction class in CCI project which code contracts uses to handle PDB files. Thus we can no longer blame Code Contracts project lagging behind Rosyln, it is Common Compiler Infrastructure: Metadata API which is not up-to-date.

private void ReadCustomMetadata(BitAccess bits) {
  int savedPosition = bits.Position;
  byte version;
  bits.ReadUInt8(out version);
  if (version != 4) {
    throw new PdbDebugException("Unknown custom metadata item version: {0}", version);
  }
  byte kind;
  bits.ReadUInt8(out kind);
  bits.Align(4);
  uint numberOfBytesInItem;
  bits.ReadUInt32(out numberOfBytesInItem);
  switch (kind) {
    case 0: this.ReadUsingInfo(bits); break;
    case 1: this.ReadForwardInfo(bits); break;
    case 2: break; // this.ReadForwardedToModuleInfo(bits); break;
    case 3: this.ReadIteratorLocals(bits); break;
    case 4: this.ReadForwardIterator(bits); break;
    default: throw new PdbDebugException("Unknown custom metadata item kind: {0}", kind);
  }
  bits.Position = savedPosition+(int)numberOfBytesInItem;
}

When an unhandled metadata kind is encountered, the method throws a PdbDebugException which is what we are seeing in the error message of ccrewrite.exe. We can try to handle this code or maybe we can get around just by not throwing the exception at all.

For example code that does not build see https://github.com/krk/CodeContractsRosyln

THE SOLUTION

We chose the road taken in this case, modifying switch statement to ignore unknown metadata kinds. To modify the switch statement, we need an IL editor such as ildasm/ilasm or reflexil. I will skip the modification step for brevity and highlight the removed part of the ReadCustomMetadata method:

private void ReadCustomMetadata(BitAccess bits)
{
	int position = bits.Position;
	byte b;
	bits.ReadUInt8(out b);
	if (b != 4)
	{
		throw new PdbDebugException("Unknown custom metadata item version: {0}", new object[]
		{
			b
		});
	}
	byte b2;
	bits.ReadUInt8(out b2);
	bits.Align(4);
	uint num;
	bits.ReadUInt32(out num);
	switch (b2)
	{
	case 0:
		this.ReadUsingInfo(bits);
		break;
	case 1:
		this.ReadForwardInfo(bits);
		break;
	case 2:
		break;
	case 3:
		this.ReadIteratorLocals(bits);
		break;
	case 4:
		this.ReadForwardIterator(bits);
		break;
	default:
		throw new PdbDebugException("Unknown custom metadata item kind: {0}", new object[]
		{
			b2
		});
	}
	bits.Position = position + (int)num;
}

Now we need to make the same modification in other applications, namely ccdocgen.exe, ccrefgen.exe, ccrewrite.exe files in addition to cccheck.exe. We can see that our modified code contracts can handle Roslyn generated PDB files that have a dynamic local without any visible problems, hence solving the problem.

1>CodeContractRewrite:
1> “C:\Program Files (x86)\Microsoft\Contracts\Bin\ccrewrite.exe” “@{0}ccrewrite.rsp”
1> elapsed time: 199.3108ms
1> Touching “obj\Debug\{0}.rewritten”.

Windows Servislerinin İnternet Olmayan Sunucuda Çalışmaması

Bu yazımızda kendi yazdığımız windows servislerinin çalışmamasında yapılabilecek bazı kontroller ve bu kontroller işe yaramadığında yapılabilecek işlemler yer almaktadır.

“Lokalde çalışıyor”, “önceden çalışıyordu”, “başka sunucuda çalışıyor” önermelerine karşı kanıt yoluyla yanlışlama ve sorunun tespiti ile çözümü hakkında kısa bir yazı.

Problem

Bir sunucuya yeni kurulan windows servisi çalışmıyor. Servis yöneticisinden ilgili servis başlatılmak istenildiğinde zamanaşımına uğrayarak hata veriyor.

Şüphe I

Servis başladığında veritabanına hangi ayarlar ile başladığını kaydediyor. Servisin başlarken ilk yaptığı işlerden biri veritabanı ile ilgili bir işlem olduğundan ve bahsedilen kaydın da veritabanında bulunmamasından dolayı ilk olarak veritabanı erişiminden kaynaklı hata olduğu şüphesi oluştu. Daha önce aynı veritabanına ulaşan kullanıcı nasıl olur da erişemez hale gelirdi gibi soruları sormamak gayet doğaldır. Müşteri tarafından yapılabilecek işlemlerde sınır aramamak gerekir. Kullanıcı değişmiş haber verilmemiş olabilir, şifre değişmiş haber verilmemiş olabilir, veritabanı değişmiş haber verilmemiş olabilir, integrated authentication kullanıldığı için windows kullanıcısının şifresi zamanaşımına uğramış, değişmesi gerekiyor olabilir. Neyse ki bu gibi şüpheleri elemek nispeten kolay bir takım işlemler gerektiriyor.

Veritabanında sorun olmadığı tespit edildi, kullanıcılar ile ilgili değişen bir detaya da rastlanmadı.

Şüphe II

Veritabanında sorun yoksa ve servisin ilk yaptığı işlerden biri veritabanına bağlanmak ise servisin başlayıp durmasından çok hiç başlamamış olmasından şüphelenmek gerekir.

Servislerimiz bir preprocessor tanımı sayesinde “Debug” konfigürasyonunda derlendiğinde komut satırı uygulaması olarak, “Release” konfigürasyonunda derlendiğinde ise windows servisi olarak bir imaj(exe dosyası) oluşturuyor. Servislerin yanlışlıkla “Debug” modunda derlenerek sunucuya kurulduğu şüphesi oluştu.

Yapılan dosya karşılaştırma kontrollerinden sonra sunucudaki windows servisi uygulamasının “Release” konfigüyasyonunda derlenerek sunucuya yüklendiği tespit edildi.

Şüphe III

Kainattan şüphelenildi, fazla zaman kaybetmeden işletim sisteminden şüphelenildi. Uygulama çalışıyor muydu yoksa proses dahi oluşturulamadan hata mı alınıyordu? Bu önermenin karşılığını bulabilmek için eski dostumuz “Görev Yöneticisi” yardımımıza koşuyor. Görev yöneticisi açıkken windows servisi ile ilişkili bir prosesin yaratıldığını, hata almadan hemen önce de öldürüldüğünü yakalayabildik. Bu durumda proses başladıktan sonra fakat kontrol .NET’e geçemeden önce alınan bir hata ile karşı karşıyaydık.

Tespit I

Windows servisi başlarken .NET’e geçmeden hata alıyor. Hatanın doğrudan uygulama kaynaklı olmadığı da “Şüphe II” başlığında tespit edilmişti. Prosesin hafıza dökümünün(memory dump) incelenmesine karar verildi.

Hafıza dökümünün alınması

Görev yöneticisinden ilgili prosese sağ tıklanarak “Full Memory Dump” alınır. Daha sonra dosya, Windows Debugging Tools yüklü olan, sunucudan ayrı bir bilgisayara aktarılarak incelenebilir. Sunucu 64-bit ise, incelemenin yapılacağı bilgisayarın da en az 64 bit olması gerekmektedir.

Yardımımıza koşacak olan uygulama, windows kernel debugger, namı diğer ntsd, namı diğer cdb. Arayüz sevenler windbg kullanabilir, biraz daha rahat ama yine de dosyayı açtıktan sonra komut satırında devam etmek gerekiyor. Bu noktadan sonra windbg, debugger anlamında kullanılmıştır.

Bellek Dökümünün İncelenmesi

SoS’u WinDbg’ye yüklemeden önce analiz edilen her bellek dökümünde kontrol edilmesi gereken alanları inceliyoruz.

Dosyayı WinDbg’ye yüklediğimizde aşağıdaki gibi bir ekran bizi karşılamalıdır.

image

Bellek dökümünü kotarılmamış istisnai durumdan(unhandled exception) oluşmadığı için, manuel olarak alındığı için doğrudan aktif thread’in call stack’ini inceleyebiliriz.

Aktif thread’in stack trace’ini görmek için kb yazıp entera basıyoruz.

Adreslere, parametre değerlerine ve metod içerisindeki satırlara dikkat etmeden akışı sezmeye çalışıyoruz. İncelediğimiz call stack, 4 farklı gruptan çağrı içeriyor. En üstteki NtWaitForSingleObject, en son girilen metodu gösteriyor, en alttaki RtlUserThreadStart ise bulunulan thread için ilk çalıştırılan metodu gösteriyor.

Stack traceini kabaca inceleyecek olursak:

  1. İlk grup koyu mavi, thread’i başlatıp kontrolü WinMain metoduna aktaracak olan işletim sistemi metodları. WinMain, .NET uygulamalarında hemen mscoree.dll içindeki CorExeMain metodunu çağırarak kontrolü .NET’e devreder. (Adına WinMain denmesine rağmen önemli olan adresi olduğu için adı farklı olabilir. )
  2. İkinci grup turuncular, .NET’in windows servisimizi çalıştırırken harcadığı çabaların bir kısmını içermektedir.
    1. CorExeMain’den sonra AppDomain yüklenir.
    2. ClassLoader, .NET Main entry point metodunun hangi sınıfta olduğunu bulup ilgili MSIL kodlarını derlemek ister.
    3. PreJit (JIT-derleme öncesi) Main metodunu derlemek üzere harekete geçer.
    4. Hangi assembly’de olduğu bulunan metod, hafızaya yüklenerek derlenecektir.
    5. Assembly hafızaya yüklemeden önce imza kontrolleri yapılır (DoLoadSignatureChecks) (Şüphe IV bu noktada oluşmaya başlıyor)
    6. mscorsec modülü, yayıncıyı bulmak ister. (GetPublisher)
  3. Üçüncü grup bordolar, mscorsec modülünün isteği üzerine yüklenen wintrust ve ardından gelen crypt32 ve cryptnet modüllerini içerir.
    1. Wintrust modülü, WinVerifyTrust metodu ile yüklenmek istenen assembly’lerin Authenticode imzalı olanlarının güvenilirlik kontorlü yapılır.  Authenticode, .NET’ten bağımsız olan, Microsoft’un exe ve dll’ler için sunduğu HTTPS/SSL olarak düşünülebilir.
    2. crypt32’de bir takım sertifika kontrolü görünüşlü metodların çağrıldığı aşikar.
    3. cryptnet modülü ise webden bir bilgi indirmeye çalışıyor. (Şüphe IV bu noktada oluştu)
  4. Dördüncü grup açık maviler, muhtemelen bir grup IRP(I/O Request Packet)’nin tamamlanmasını senkron olarak bekleyen cryptnet aksamlarına bağlılar.

0:000> kb RetAddr : Args to Child : Call Site 000007fe`fd5710dc : 000007fe`fdebc943 00000000`775c5133 00000000`0018bf68 00000000`00000000 : ntdll!NtWaitForSingleObject+0xa 000007fe`faf9a06a : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`000003f8 : KERNELBASE!WaitForSingleObjectEx+0x79 000007fe`faf976da : 00000000`00000000 000007fe`fafabc04 00000000`199a7520 00000000`00003a98 : cryptnet!CryptRetrieveObjectByUrlWithTimeout+0x263 000007fe`fd6948b0 : 00000000`04205004 00000000`00000000 00000000`04205004 000007fe`00003a98 : cryptnet!CryptRetrieveObjectByUrlW+0x20f 000007fe`fd6947de : 00000000`04205004 00000000`00000001 00000000`00000000 00000000`199a7520 : crypt32!ChainRetrieveObjectByUrlW+0x80 000007fe`fd71b5a1 : 00000000`19982a60 00000000`00000000 00000000`00000048 00000000`199a7520 : crypt32!CCertChainEngine::RetrieveAuthRootAutoUpdateObjectByUrlW+0x135 000007fe`fd71bd14 : 00000000`00000006 00000000`1997e7c0 00000000`00000000 000007fe`00000000 : crypt32!CCertChainEngine::WireRetrieveAutoUpdateCab+0x151 000007fe`fd6a9b14 : 00000000`00000000 00000000`0018c240 00000000`00000000 01cdc27c`e93fbf58 : crypt32!CCertChainEngine::GetTimeValidDisallowedCertAutoUpdateCtl+0xe8 000007fe`fd66f046 : 00000000`19982a60 00000000`1997e7c0 00000000`00000000 00000000`19947700 : crypt32!CCertChainEngine::GetChainContext+0x7e 000007fe`fd5e4f70 : 00000000`19982a60 00000000`1997e7c0 00000000`19984094 00000000`48000001 : crypt32!CertGetCertificateChain+0x100 000007fe`fd5e4ccf : 00000000`0018c3a0 00000000`00000000 00000000`0018c348 00000000`00000000 : wintrust!_WalkChain+0x2b2 000007fe`fd5e1f56 : 00000000`00000000 00000000`00000000 00000000`0018c620 00000000`0018c460 : wintrust!WintrustCertificateTrust+0xea 000007fe`fd5e1057 : 00000000`0018c620 000007fe`f9805d23 00000000`00000000 00000000`00000000 : wintrust!WTHelperGetFileHash+0x48e 00000642`ffaf7ed1 : 00000000`0028b7d0 00000000`00000003 00000000`00000000 00000000`00000000 : wintrust!WinVerifyTrust+0x70 000007fe`f7a98aac : 00000000`0028b7d0 00000000`00000000 00000000`00000003 00000000`0018c6f8 : mscorsec!GetPublisher+0x139 000007fe`f77e0ae7 : 00000000`1993c440 000007fe`f77ff322 00000000`00000000 00000000`0018c6f8 : mscorwks! ?? ::FNODOBFM::`string'+0x4499c 000007fe`f77cd94d : 00000000`0000002a 00000000`00000000 00000000`00000000 00000000`00000000 : mscorwks!PEAssembly::DoLoadSignatureChecks+0x37 000007fe`f77d9f80 : 00000000`1993c440 00000002`00000000 00000000`19951320 00000000`0028b6d0 : mscorwks!PEAssembly::PEAssembly+0x12d 000007fe`f77e6481 : 00000000`0000000b 00000000`002444a0 ffffffff`fffffffe 00000000`0025c9b0 : mscorwks!PEAssembly::DoOpen+0x11c 000007fe`f770afda : 00000000`19951320 00000000`0018cc88 00000000`00000000 000007fe`00000000 : mscorwks!PEAssembly::Open+0x71 000007fe`f76fb08a : 00000000`002434f0 00000000`0018cef0 00000000`00000001 00000000`19936ad0 : mscorwks!AppDomain::BindAssemblySpec+0x266 000007fe`f771ee20 : 00000000`1993c0c0 00000000`00000001 00000000`00000000 00000299`00160025 : mscorwks!PEFile::LoadAssembly+0xae 000007fe`f778df38 : 00000000`0025c9b0 00000000`00279170 000007fe`00000022 00000299`00160025 : mscorwks!Module::LoadAssembly+0x120 000007fe`f7768123 : 00000000`02000048 00000008`8f855083 00000000`0018d450 00000000`00000000 : mscorwks!Assembly::FindModuleByTypeRef+0xec 000007fe`f7787490 : 00000000`00000000 00000000`0018d558 00000000`010b6200 000007fe`00000000 : mscorwks!ClassLoader::LoadTypeDefOrRefThrowing+0x4a3 000007fe`f776e76f : 000007ff`00027cd8 00000000`00000001 00000000`0a000039 00000000`0018d880 : mscorwks!ClassLoader::LoadTypeDefOrRefOrSpecThrowing+0x58 000007fe`f776dfc4 : 000007ff`00029710 000007ff`00000006 00000000`010bc6bc 00000000`00000000 : mscorwks!MemberLoader::GetDescFromMemberDefOrRefThrowing+0x51f 000007fe`f776d698 : 00000000`00000001 00000000`0a000039 00000000`5df3edc8 000007fe`f774ca03 : mscorwks!MemberLoader::GetMethodDescFromMemberDefOrRefOrSpecThrowing+0xd4 000007fe`f77642d0 : 00000000`0018e2a0 000007ff`000296b8 000007ff`00000001 00000000`00000001 : mscorwks!CEEInfo::findMethodInternal+0x218 000007fe`f8037659 : 00000000`19e3b818 00000000`0a000039 00000000`0018de00 00000000`00000000 : mscorwks!CEEInfo::findMethod+0xf0 000007fe`f8030ab5 : 00000000`0018de00 00000000`00000028 00000000`0a000039 00000000`0000001e : mscorjit!GenIR::GenIR_FgCall+0x149 000007fe`f803ad43 : 00000000`19e20100 00000000`19e202d8 00000000`5df36074 00000000`0018de00 : mscorjit!ReaderBase::fgBuildPhase1+0x2a5 000007fe`f8018597 : 00000000`00000000 00000000`0018de00 00000000`00000000 00000000`00000000 : mscorjit!ReaderBase::fgBuildBasicBlocksFromBytes+0x93 000007fe`f7feed71 : 00000000`0018e2b8 00000000`19920540 00000000`00100010 00000000`010b8efc : mscorjit!ReaderBase::MSILToIR+0xa7 000007fe`f7fe51e0 : 00000000`0025c9b0 00000000`19951b90 00000000`00274f00 00000000`010b8886 : mscorjit!THX_dop2+0x2a1 000007fe`f77be279 : 00000000`1991d9b0 000007ff`00029710 000007ff`00029710 000007ff`000296b8 : mscorjit!PreJit::compileMethod+0xc0 000007fe`f77a94d2 : 00000000`19920540 000007ff`00029710 00000000`0018e400 00000000`00100010 : mscorwks!invokeCompileMethodHelper+0xd1 000007fe`f77a95c5 : 00000000`00000000 000007ff`000296b8 00000000`00000000 000007fe`00000000 : mscorwks!invokeCompileMethod+0x72 000007fe`f77963cb : 00000000`19920540 00000000`0018e2b8 00000000`00000003 00000000`00100010 : mscorwks!CallCompileMethodWithSEHWrapper+0xbd 000007fe`f7796a1a : 00000000`19930ed0 00000000`00000000 00000000`00000000 00000000`00000000 : mscorwks!UnsafeJitFunction+0x25b 000007fe`f7c30d5c : 000007ff`000296b8 00000002`00000000 00000000`00000000 00000000`00000000 : mscorwks!MethodDesc::MakeJitWorker+0x1ea 000007fe`f777de2a : 48cf9094`0b9ee7b6 00000000`0023d320 00000000`00000000 000007ff`000296b8 : mscorwks!MethodDesc::DoPrestub+0x54c 000007fe`f78c0167 : 00000000`01376fb8 00000000`012e2fa0 00000000`013777c8 00000000`0025c9b0 : mscorwks!PreStubWorker+0x1fa 000007ff`001a0829 : 00000000`013777c8 88cf90a4`cf27b7b6 00000000`00000002 00000000`00000000 : mscorwks!ThePreStubAMD64+0x87 000007ff`001a028f : 00000000`012e2fa0 00000002`18711a00 00000000`0018eba0 00000000`0136cf58 : 0x000007ff`001a0829 000007ff`001a0161 : 00000000`012e2fa0 000007ff`000233d0 00000000`0025fac0 00000000`000000d0 : 0x000007ff`001a028f 000007fe`f78c0282 : 000007ff`000239b8 000007fe`f7773d09 00000000`00000000 000007ff`000239a8 : 0x000007ff`001a0161 000007fe`f77a4363 : 00000000`00000000 000007fe`0000006b 000007fe`f7676a30 00000000`00000000 : mscorwks!CallDescrWorker+0x82 000007fe`f7c9b751 : 00000000`0018edb8 00000000`00000000 00000000`00000001 00000000`00000000 : mscorwks!CallDescrWorkerWithHandler+0xd3 000007fe`f780b097 : 00000000`00000000 000007ff`000239a8 00000000`00000000 00000000`0018f220 : mscorwks!MethodDesc::CallDescr+0x2b1 000007fe`f782e1fc : 00000000`00000000 00000000`00000000 00000010`009a0019 00000000`00000000 : mscorwks!ClassLoader::RunMain+0x22b 000007fe`f7d87a2d : 00000000`0018f810 00000000`00000000 00000000`0026b798 00000000`00000200 : mscorwks!Assembly::ExecuteMainMethod+0xbc 000007fe`f783bd17 : 00000000`00000000 00000000`00000000 00000000`00000000 000007fe`f7858442 : mscorwks!SystemDomain::ExecuteMainMethod+0x47d 000007fe`f781e1c4 : ffffffff`fffffffe 00000000`00000000 0000c275`00000000 00000000`00000000 : mscorwks!ExecuteEXE+0x47 000007fe`f9763309 : ffffffff`ffffffff 00000000`0025c9b0 00000000`00000000 00000000`0018fad8 : mscorwks!CorExeMain+0xac 000007fe`f97f5b21 : 000007fe`f781e118 000007fe`f97632c0 00000000`00000000 00000000`00000000 : mscoreei!CorExeMain+0x41 00000000`7736652d : 000007fe`f9760000 00000000`00000000 00000000`00000000 00000000`00000000 : mscoree!CorExeMain_Exported+0x57 00000000`7759c521 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : kernel32!BaseThreadInitThunk+0xd 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ntdll!RtlUserThreadStart+0x1d

Şüphe IV

Windows servisi başlatılırken bazı aksamlar internete erişmeye çalışıyor. Windows servisinin hata verdiği sunucuda internet erişimi olmadığı için hemen cevap alamayan aksamlar, kendi zamanaşımlarından önce service control utility(services.msc, sc.exe) uygulamasını zamanaşımına uğratıyor.

Tespit II

Windows servisi işletim sistemi tarafından başlatılırken uygulama ve referansları üzerinde Authenticode dijital imza kontrolü yapılırken internete erişmek istiyor. Bu erişim başarısız olduğundan CryptRetrieveObjectByUrlWithTimeout metoduna geçilen zamanaşımı süresi geçene kadar thread bu metoddan çıkamıyor.

Zamanaşımı süresi, varsa kayıt defterindeki HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\ServicesPipeTimeout alanından gelecektir. Varsayılan kurulumlarda ServicesPipeTimeout  anahtarı yoktur ve Microsoft kaynaklarında bu değer için kesin bir rakam verilmemekle birlikte “30 saniyeden az” olduğundan bahsedilmektedir.

CryptRetrieveObjectByUrlWithTimeout metoduna geçilen timeout süresi, hex olarak 0x3a98 olup ondalık 15000 değerine karşılık gelmektedir. Bu değerin de 15 saniye olduğu düşünülebilir. Neden kesin yazmıyorum, çünkü CryptRetrieveObjectByUrlWithTimeout metodunun erişebildiğim bir dokümantasyonu yok. Rusça bir kaynakta geçen CryptRetrieveObjectByUrlW metodunun parametre sıralaması ile CryptRetrieveObjectByUrlWithTimeout  parametre sıralamasının en azından timeout değerine kadar aynı olduğunu varsaydım.

Windows, Authenticode kontrolü yapmak zorunda mı?

Windows’u bırakalım, .NET yapmak zorunda mı? .NET’te authenticode mekanizmasını baypas etmenin en az bir yolu var, o da app.config dosyasına yerleşecek bir adet generatePublisherEvidence anahtarı.

<configuration>
    <runtime>
        <generatePublisherEvidence enabled="false"/>
    </runtime>
</configuration>

Ama-fakat güvenlik? Microsoft, .NET uygulamalarında Authenticode yerine strong-name signing tavsiye ediyor.

Peki ya uygulamamız native windows uygulaması olsaydı?

Native windows uygulamalarında toptan çözüm olarak domain policyler ile gelebilen SRP ayarlarında değişikliğe gidilebilir. Bu değişiklik, Internet Explorer vasıtası ile de yapılabilir. İşaretli checkbox boş olmalıdır. Dikkat, bu ayar çalınmış sertifikaların kullanıldığı farklı güvenlik zafiyetlerine davetiye çıkartabilir.

image

Meraklısına

Hangi URL Çağrılıyor?

Bir url çağrılıyor ama nasıl bir url, her uygulama hangi URL’i çağırıyor sorusunun cevabını alabilmek için CryptRetrieveObjectByUrlWithTimeout metodunun 3. parametresinin gösterdiği adrese unicode olarak bakmak yeterli.

0:000> du 00000000`199a7520
00000000`199a7520  "http://ctldl.windowsupdate.com/m"
00000000`199a7560  "sdownload/update/v3/static/trust"
00000000`199a75a0  "edr/en/disallowedcertstl.cab"

Hedef URL: http://ctldl.windowsupdate.com/msdownload/update/v3/static/trustedr/en/disallowedcertstl.cab

Not: Farklı URL’ler ile de karşılaşıldı.

Hangi Assembly Yüklenmek İstenirken Hata Alınıyor?

Peki bu URL’in çağrılmasına hangi assembly sebep olmuş? Proses imajı mı yoksa referans verilen assembly’lerden biri mi?

mscorsec modülünün GetPublisher metoduna verilen ilk parametreye baktığımızda zanlının Enterprise Library‘nin bir bileşeni olduğunu görüyoruz.

0:000> du 0000000`0028b7d0
00000000`0028b7d0  "D:\XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
00000000`0028b810  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX\Mi"
00000000`0028b850  "crosoft.Practices.EnterpriseLibr"
00000000`0028b890  "ary.ExceptionHandling.dll"

Sonuç

Windows servisine yeni dahil edilen, Authenticode imzalı dll’lerden oluşan Enterprise Library 5.0 bileşenlerinin yüklenirken Authenticode sertifika geçersizlik listelerinin yüklenmek istenmesi neticesinde alınan zamanaşımının neden olduğu service controller zamanaşımı dolayısıyla, Enterprise Library 5.0 referansı olan hiç bir windows servis internet bağlantısı olmayan sunucumuzda çalışmıyordu.

Authenticode imza kontrolü, app.config’e generatePublisherEvidence anahtarı eklenerek baypas edildi.

  • “lokalde çalışıyor”: Windows servisinin geliştirme ortamında internet erişimi mevcut olduğunda Authenticode kontrolleri zamanaşımına yol açmıyordu.
  • “önceden çalışıyordu”: Uygulamada yapılan yükseltme ile Enterprise Library’nin 5.0 sürümüne geçildi. Bu geçişten önce dll’ler Authenticode imzalı olmadığından Authenticode kontrolü yapılmıyordu.
  • “başka sunucuda çalışıyor”: “Başka sunucu” internet erişimli olduğundan Authenticode kontrolü yapılmıyordu

q.e.d.

git getir, git götür

Versiyon kontrol sistemi olarak svn, mercurial, bazaar ve git kullandıktan sonra en sorunsuz ve svn ile git-gel(roundtrip) kullanılabilen git’I tercih ettim. git’in komutlarından veya işleyişinden bahsedecek değilim, bu konularda pek çok makale bulabilirsiniz. Sadece kullandığım iki adet kısayolu paylaşmak istedim. Sıklıkla svn ile kullandığım git’te svn’deki değişiklikleri getirmek için ve yapılan değişiklikleri svn’e göndermek için aşağıdaki komutlar kullanılıyor.

  • Değişiklikleri getirmek için: git svn rebase
  • Değişiklikleri svn’e göndermek için: git svn dcommit

Bu komutları her sefer yazmak bir süre sonra banal olmaya başladı. git kullanırken kendi komut adlarınızı tanımlayarak varolan komutları çağırabilirsiniz.

Her ne kadar git’i git olarak okumak mübah olsa da aşağıdaki kısayolları ekledim ve kullanıyorum.

  • getir: svn rebase
  • gotur: svn dcommit

git getir ve git gotur yazdığınızda istediğiniz işlemler git tarafından zevkle yapılacaktır.

Bir Polinomu İkinci Derece Başka Bir Polinoma Bölmede Kalan

Matematik ve polinomlar ile ilgili bu yazımızda karşılaşılan bir problemin analitik çözümüne kısaca değineceğiz.

Polinom kalan teoremine göre, P(x) polinomunun (x-a) binomuna bölümünden kalan, P(a)’dır. Diğer bir deyişle:

Polinom bölme.

P(x) polinomunun (x-a) binomuna bölümünden kalan A, (x-b) binomuna bölümünden kalan B olsun.

Bizden istenen P(x) polinomunun, (x-a)(x-b) polinomuna bölümünden kalandır. Problemi kısaca ifade edelim:

Polinom bölme.

Bildiklerimizi yerlerine koyalım:

A = P(a) = (a-a) \cdot (a-b) \cdot Q(x) + K(a) = K(a)

B = P(b) = (b-a) \cdot (b-b) \cdot Q(x) + K(b) = K(b)

\deg(K(x)) = 1 \implies K(x) = m \cdot x + n \ni m,n \in \mathbb{R}

A = m \cdot a + n

B = m \cdot b + n

A - B = m \cdot (a - b)

m = \frac{A-B}{a-b}

b \cdot A = m \cdot a \cdot b + b \cdot n

a \cdot B = m \cdot a \cdot b + a \cdot n

b \cdot A - a \cdot B = n \cdot (b-a)

n = \frac{b \cdot A - a \cdot B}{b-a}

SONUÇ

Aşağıdakine benzer bir formülü tüm çabalarım neticesinde googleda bulamadım, belki de ne yazacağımı bilemediğimdendir…

K(x) = \frac{A-B}{a-b} \cdot x + \frac{a \cdot B - b \cdot A}{a-b}

ÖRNEK

P(x) polinomunun (x+2) binomuna bölümünden kalan 3, (x-4) binomuna bölümünden kalan -9’dir. P(x)’in (x+2)(x-4) polinomuna bölümünden kalan nedir?

Verilenler:

a = -2

b = 4

A = 3

B = -9

Formülümüzde yerine koyalım:

K(x) = \frac{3- (-9)}{-2-4} \cdot x + \frac{(-2) \cdot (-9) - 4 \cdot 3}{ -2-4 }

K(x) = \frac{12}{-6} \cdot x + \frac{18-12}{-6}

UTM Koordinat Sistemi ve Türkiye Paftaları

Koordinat Dönüşümü ve Paftalar

Serbestçe kullanabileceğiniz bir silverlight uygulaması olan KorTrans SL v1.0’a bu linkten erişebilirsiniz.

  • Tüm Türkiye’deki paftaları, haritadan nokta seçerek bulabilirsiniz.
  • UTM, Derece-Dakika-Saniye ve Ondalıklı Derece sistemleri arasında dönüşüm yapabilirsiniz.
  • Pafta ismini “İSTANBUL-F22-b3” veya “F22-b3” şeklinde girerek de paftayı bulabilirsiniz.
  • Seçilen pafta üzerinde UTM grid çizgilerini gösterebilirsiniz.
  • Ölçeğinize göre belirlenen komşu paftaları görebilirsiniz.Her zamanki gibi değerli yorumlarınızı bekliyoruz.

Program silverlight ile çalışır. Silverlight, Microsoft’un bir platformudur, yüklemek çok kolaydır.

KorTrans SL

Kullanım

Programda markeri sürükleyerek koordinatı belirlersiniz.

Not: Sol üst köşedeki dönüşüm fonksiyonlarını denemeyi unutmayın!

Linkler

KorTrans SL: http://www.dissipatedheat.com/kortrans

OpenCV ile WebCam Görüntüsü İşleme

OpenCV Nedir?

OpenCV, açık kaynaklı bir bilgisayarlı görselleştirme kütüphanesidir. Amacı görüntü işleme ve görselleştirmede sık kullanılan metodların kolaylıkla erişilebilir olmasını sağlamaktadır. Yazımızda kullandığımız OpenCV 2.2 ile webcam görüntüsü işlerken bu kolaylığı farkedeceğiz.

Webcam görüntüsünü alacağım derseniz bir yolu da DirectShow kullanmaktır ki bu yol uzun ince bir yoldur, bkz. DirectShow Webcam

Webcam Görüntüsünü Almak

Yüklü ve windows tarafından tanınmış olan webcaminizden OpenCV kullanarak görüntü almak için yazmanız gereken kod sadece tek bir satırdır.

CvCapture* capture = 0;
capture = cvCaptureFromCAM(0);
IplImage* videoFrame = NULL;

videoFrame = cvQueryFrame(capture); // kameradan görüntü alınır

Gerekenler

  • VS 2010 ve C/C++ Bilgisi
  • OpenCV 2.2 Kurulumu
  • OpenCV’yi kendiniz patchlemek isterseniz:
    • CMake, OpenCV’yi patchledikten sonra build etmek için.
    • OpenCV 2.2 Windows webcam patchi: İngilizce
  • Patchli dll ve libleri indirmek isterseniz:

İzlenen Yol

OpenCV 2.2 Patch

OpenCV 2.2 sürümünde mevcut olan bir bug, windows makinalarda görüntü alınmasına engel olmaktadır. Bu bugın varlığını keşfedinceye kadar bilgisayarımdan ve kameramdan şüphe etmiştim, neyseki şüphelerim yersizmiş. Patch deyince gözünüz korkmasın, sadece tek bir dosyada iki satır değişiklik yapmak gerekiyor. Bu satırlar için bkz. OpenCV 2.2 patch.

Yok ben dosyalarımı patchli kullanırım derseniz İndirmeler bölümünden OpenCV patch dosyasını indirip içindeki dll dosyalarını c:\opencv2.2\bin içerisinde, lib dosyalarını da c:\opencv2.2\lib dizinine oradaki dosyaların üzerine yazarak kopyalayabilirsiniz.

Visual Studio Projesi

  • Empty Win32 Console Project yaratarak yolculuğumuza başlıyoruz.
  • Projemizin özellik sayfasında VC++ Directories’de includeları ekliyoruz:
    C:\OpenCV2.2\include
  • Projemizin özellik sayfasında VC++ Directories’de libraryleri ekliyoruz:
    C:\OpenCV2.2\lib
  • Kullanacağımız kütüphane dosyalarını Linker->Input->Additional Dependencies’e ekliyoruz.
    opencv_core220.lib
    opencv_highgui220.lib
    opencv_imgproc220.lib
  • Yaratacağımız main.h dosyasına içeriği ekliyoruz:
    #pragma once // Header dosyasına birden fazla referans olsa bile sadece 1 kere işlensin.
    
    #include <stdio.h>
    #include <stdlib.h>
    
    #include "opencv2\opencv.hpp"
    
  • Yaratacağımız main.cpp dosyasına webcamden capture edip görüntüyü negatif yaparak ekranda göstermeye yarayacak aşağıdaki kodu ekliyoruz.
    fa77aefe22277074939a2cee8fe74ea7

Gerçek Zamanlı Webcam Negatifi

İndirmeler

Dosyaları açabilmek için farklı kaydederek uzantısını 7z yapınız.
Patchlenmiş OpenCV dosyaları: OpenCV2.2 webcam patch
Örnek Proje Kaynakları: HelloOpenCV

CUDA ile Matris Çarpımı – 2

Matris Çarpımı CUDA – 2

Bir önceki yazımızda CUDA ile matris çarpımının nasıl yapılabileceğini en basit hali ile görmüştük. Burada geçen sefer kaldığımız yer olan hafıza erişim optimizasyonuna devam ediyoruz.

En son matMul2 isimli kernel içerisinde toplam alınan satırda hafızaya yapılan yazmaları azaltmıştık.

// matMul1 (n adet global store):

d_C[ cIdx ] = 0;

// C matrisinin her bir hücresi için
for(int j=0; j<n; j++)
{
	// her bir eleman için C matrisinin bir elemanı okunur ve yazılır.
	d_C[ cIdx ] += *loc( d_A, n, i, j ) * *loc( d_B, r, j, k ); // global hafızaya yazılır(d_C).
}

// matMul2 (1 adet global store):

float val = 0; // ara toplam değişkeni

// C matrisinin her bir hücresi için
for(int j=0; j<n; j++)
{
	val += *loc( d_A, n, i, j ) * *loc( d_B, r, j, k ); // local registera(val) yazılır.
}

// C matrisine bir kere yazılır.
d_C[ cIdx ] = val;

Paylaşık Hafıza (Shared Memory)

Paylaşılmış olmayan hafıza mı vardır dediğinizi duyar gibiyim. Global Hafıza da paylaşılmıştır elbet, herkes yazabilir herkes okuyabilir. Fakat burada bir nVidia terimi olarak geçen “paylaşık hafıza” bir blok içerisindeki threadler arasında paylaşılmıştır. Yani ancak aynı blok içerisindeki threadler aynı yeri okuyabilir ve aynı yere yazabilir.

Bir bloktaki threadler paylaşık hafızaya yardımlaşarak yükledikleri verileri kullanabilirler.

...

Ais[threadIdx.y][threadIdx.x] = *loc( d_A, n, i, j ); // A(i,j) elemanı Ais paylaşık hafızasına yüklenir.
Bis[threadIdx.y][threadIdx.x] = *loc( d_A, n, j, k ); // A(j,k) elemanı Bis paylaşık hafızasına yüklenir.

// kullanılacak elemanlar paylaşık hafızaya yüklenir.
__syncthreads(); // syncthreads, bloktaki tüm threadlerin bu noktaya erişmesini bekletir.

for(int k=0; k<BLOCK_SIZE;k++)
{
	val += Ais[threadIdx.y][k] * Bis[k][threadIdx.x];
}

// tüm threadlerin sonucu yazması beklenir.
__syncthreads(); // syncthreads, bloktaki tüm threadlerin bu noktaya erişmesini bekletir.

2. Optimizasyon (Paylaşık Hafıza)

Yapılan optimizasyonda paylaşık hafıza kullanılarak global hafızadan okuma sayısı düşürülmüştür.

__global__
void matMul3(
	float* d_C,
	float* d_A,
	float* d_B,
	int m,
	int n,
	int r)
{

	__shared__ float Ais[BLOCK_SIZE][BLOCK_SIZE];
	__shared__ float Bis[BLOCK_SIZE][BLOCK_SIZE];

	int i = blockIdx.x * BLOCK_SIZE + threadIdx.x;
	int k = blockIdx.y * BLOCK_SIZE + threadIdx.y;

	int cIdx = i*m + k;

	float val = 0; // ara toplam değişkeni

	for(int j=0; j < n / BLOCK_SIZE; j++)
	{
		Ais[threadIdx.y][threadIdx.x] = *loc( d_A, n, i, j );
		Bis[threadIdx.y][threadIdx.x] = *loc( d_B, n, j, k );

		// kullanılacak elemanlar paylaşık hafızaya yüklenir.
		__syncthreads();

		for(int k=0; k<BLOCK_SIZE;k++)
		{
			val += Ais[threadIdx.y][k] * Bis[k][threadIdx.x];
		}

		// tüm threadlerin sonucu yazması beklenir.
		__syncthreads();
	}

	// C matrisine bir kere yazılır.
	d_C[ cIdx ] = val;
}

Zamanlama

512 x 512 boyutlarında iki matrisin çarpım sürelerini karşılaştırabiliriz.

Versiyon Hız (ms) Hızlanma
Host 9619 1x
MatMul1 509 19x
MatMul2 183 53x
MatMul3 72 135x

Referanslar

Proje dosyasını açabilmek için farklı kaydederek uzantısını 7z yapınız.
Kaynakları indir: CUDA matris carpimi 2

Bézier Curves in Bing Silverlight Maps

Bézier Curves in Bing Silverlight Maps

Connecting geographical locations on Bing Maps with Bézier curves.

Download sample: MapBezier Silverlight Application

Introduction

Bing Maps Silverlight Control library has a MapPolyline class for showing connected points on the map. I wanted my points to be smoothly connected but there wasn’t out-of-the-box support so I developed a custom control deriving from MapShapeBase class.

Bézier Curve on map.

Background

Every developer who messed with Expression Blend or Gimp long enough knows by experimentation how a Bézier curve behaves. Basically a cubic Bézier curve has an initial point (P1), two control points (B1, B2) and a final point (P2).

Bézier Curve

Cubic Bézier Curve

The formula that defines a cubic Bézier curve is:

Cubic Bézier Curve

where t is in the interval [0,1].

Terms multiplying P1, B1, B2, P2 are called the basis functions for the cubic Bézier. Our points determine how much of these basis functions does the curve contains.

Basis Functions for Cubic Bézier Curve

Cubic Bézier Basis Functions

The thing is we need to calculate coordinates of the control points such that our points of interest are on the curve.

Polyline, Bézier, Catmull-Rom

Polyline, Bézier, Catmull-Rom

So how can we calculate these control points? After researching(read googling) I have landed on cardinal splines and Catmull-Rom splines. It appears that every control point of a Catmull-Rom spline is on the curve and it is also a Bézier curve which means we can use it as PathGeometry with a Silverlight Path object.

Calculating Control Points

If we rewrite formulas from the cardinal splines page as the following, we can easily calculate control points.

Point Derivative

Control Points:

Control Points

Fitted Bézier with Control Points Visible.

Fitted Bézier with Control Points Visible

Using the code

The method that calculates the Bézier Points is as the following. GetB1 and GetB2 are straight forward implementations of the aforementioned formulas.

private PointCollection GetBezierPoints(PointCollection pts, double tension) {
 PointCollection ret = new PointCollection();

 for (int i = 0; i < pts.Count; i++) {
  // for first point append as is.
  if (i == 0) {
   ret.Add(pts[0]);
   continue;
  }

  // for each point except first and last get B1, B2. next point.
  // Last point do not have a next point.
  ret.Add(GetB1(pts, i - 1, tension));
  ret.Add(GetB2(pts, i - 1, tension));
  ret.Add(pts[i]);
 }

 return ret;
}

// To use the PointCollection returned from GetBezierPoints method in Silverlight, we need to build a Path with BezierSegments in it.
private PathFigure GetBezierSegments(PointCollection pts, double tension) {
 PathFigure ret = new PathFigure();
 ret.Segments.Clear();
 ret.IsClosed = false;

 var bzPoints = GetBezierPoints(_projectedPoints, tension);

 // First point is the starting point.
 ret.StartPoint = bzPoints[0];

 for (int i = 1; i < bzPoints.Count; i += 3) {
  ret.Segments.Add(new BezierSegment() {
   Point1 = bzPoints[i], // B1 control point.
    Point2 = bzPoints[i + 1], // B2 control point.
    Point3 = bzPoints[i + 2] // P2 start / end point.
  });
 }

 return ret;
}

// And use this PathFigure in the MapBezier as:
// Create a new PathGeometry.
var pGeo = new PathGeometry();

// Add the Bezier PathFigure to the PathGeometry.
pGeo.Figures.Add(GetBezierSegments(_projectedPoints, Tension));

// Set data of the Path to the created PathGeometry.
((Path) EncapsulatedShape).Data = pGeo;

You can use the MapBezier class just like MapPolyline and MapPolygon classes in your silverlight XAML file. See the attached sample for an example silverlight application.

<m:Map x:Name="myMap" CredentialsProvider="***">
  <m:MapLayer x:Name="layerDurak" >
    <local:MapBezier Tension="2" x:Name="plDurakGidis" Stroke="Orange" StrokeThickness="3" Opacity=".6" Locations="{Binding MyLocations, Mode=OneWay}" />
  </m:MapLayer>
</m:Map>

Note: Bing Maps Silverlight SDK is needed for compiling the sample application.

Points of Interest

It was fun messing with the Bing Maps Silverlight Control toolkit and I hope MapBezier is what you are looking for.

If you liked this, vote the article at http://www.codeproject.com/KB/silverlight/MapBezier.aspx

Koordinat Dönüşüm Fonksiyonları

Ne?

İlgilendiğimiz koordinat sistemleri, dünya yüzeyindeki herhangi bir noktayı karışıklığa mahal vermeden tarif etmeye yarar. Koordinat sistemi denildiğinde akla gelen ilk sistem x-y koordinatları olarak da hatırlanan bir 2 boyutlu dik koordinat sistemi olan kartezyen koordinat sistemidir.

Peki bahsettiğimiz gibi eğer bir koordinat sistemi karışıklığa mahal vermeden bir noktayı tarif edebiliyorsa farklı koordinat sistemlerine ne gerek var sorusu akla gelebilir, gelmelidir. Farklı koordinat sistemlerine olan ihtiyaç tamamen kullanım yeri ve kullanım kolaylığı ile ilgilidir.

Nedir?

İlgilendiğimiz koordinat sistemlerinden bahsetmeden önce harita yapımının bir aşaması olan izdüşüm (projection) almaktan bahsetmekte fayda var.

İzdüşüm Nedir?

En basit haliyle izdüşüm, bir noktanın bir yüzey üzerine düşen izidir. Biraz detaylandırırsak belli bir merkezden gelip bir noktadan veya bir noktalar kümesinin her bir noktasından geçen doğruların izdüşüm tarafından tanımlanmış olan yüzeyi kestiği noktaların geometrik yeridir diyebiliriz.

Bu biraz karışık olduysa merkezde bir ışık kaynağı olduğunu ve izdüşüm yüzeyinin bizim istediğimiz şekilde bir perde olduğunu düşünün. İzdüşümünü almak istediğimiz noktaları ışık kaynağı ile perde arasına koyarsak, perde üzerinde izdüşümünü elde ederiz.

Bizim ilgilendiğimiz izdüşümü, dünyanın (noktalar) üzerinde geçirilmiş bir silindire (perde), dünyanın merkezinden (ışık kaynağı) olan izdüşümüdür.

Mercator İzdüşümü

Türkiye’de de tapu, ruhsat, askeri ve benzeri alanlarda en çok kullanılan koordinat sistemi UTM şeklinde kısaltılan Universal Transverse Mercator (Evrensel “Uzun eksene dik” Mercator) sistemidir.

Transverse Mercator

Transverse Mercator

KorTransLib

Koordinat Dönüşüm Kütüphanesinin yazılış amacı ileride düşünülen projelerde kullanılmak üzere olduğundan sadece 6 derece dilimli UTM, enlem-boylam ve derece-dakika-saniye olmak üzere üç adet koordinat sınıfı olmakla beraber istenilen koordinat sistemleri kolaylıkla eklenebilecek şekilde tasarlanmıştır.

Coordinate Sınıfı ve Türetilmiş Sınıfları

Coordinate Sınıfı ve Türetilmiş Sınıfları

Koordinat Sınıfları

  • DecimalDegreeCoordinate
  • DegreeMinuteSecondCoordinate
  • UTMCoordinate

DECIMALDEGREECOORDINATE

Ondalık dereceli gösterim. Matematiksel hesap yaparken kolaylıkla kullanılır.

DEGREEMINUTESECONDCOORDINATE

Derece, dakika, saniye sisteminde gösterim.

UTMCOORDINATE

6 derecelik dilimli Universal Transverse Sekant Mercator izdüşüm sistemindeki koordinatlar. UTM koordinat sisteminde sağa ve yukarı değerden başka dilim bölgesi (UTM Zone) değeri de vardır. Bu değer sağa ve yukarı değerlerinin anlamını tanımlar. Türkiye’nin UTM dilimleri aşağıda gösterilmiştir.

Türkiye UTM Dilimleri

Türkiye UTM Dilimleri

Koordinatlar Sınıfları Arasında Matematiksel İşlemler

Örnek olarak herhangi iki koordinatın orta noktasının bulunmasını aşağıdaki şekilde yapabilmemiz için kullanılan TypeConverter sınıfı, kodun yazılmasında da kullanılmasında da büyük kolaylık sağlamıştır.

DecimalDegreeCoordinate dd = new DecimalDegreeCoordinate(38.4, 28.1);
UTMCoordinate utm = new UTMCoordinate(&amp;quot;35T&amp;quot;, 663890, 4568130);

DegreeMinuteSecondCoordinate dmsSonuc = new DegreeMinuteSecondCoordinate();

TypeConverter corcon = TypeDescriptor.GetConverter(typeof(DegreeMinuteSecondCoordinate));
dmsSonuc = (DegreeMinuteSecondCoordinate)corcon.ConvertFrom((dd + utm) / 2);

Yukarıda gösterildiği gibi koordinat dönüşüm işlemi sadece bir değişkene atama yapılmadan önce yapılıyor.

İki koordinatın ortalaması, karşılıklı iki köşe koordinatı bilinen bir paftanın merkezini bulurken kullanılabilir.

TypeConverter Kullanımı

  1. System.ComponentModel içerisindeki TypeConverter sınıfı miras alınarak CanConvertFrom, ConvertFrom, CanConvertTo, ConvertTo fonksiyonları yazılır.
  2. Yaratılan TypeConverter mirasçısı sınıfının hangi tipi dönüştürdüğü Nitelik(Attribute) sınıfları kullanılarak tanımlanır.
  3. TypeDescriptor sınıfı yardımı ile kullanılır.
public static Coordinate operator +(Coordinate c1, Coordinate c2)
{
  DecimalDegreeCoordinate dd1 = (DecimalDegreeCoordinate)TypeDescriptor.GetConverter(c1).ConvertTo(c1, typeof(DecimalDegreeCoordinate));
  DecimalDegreeCoordinate dd2 = (DecimalDegreeCoordinate)TypeDescriptor.GetConverter(c2).ConvertTo(c2, typeof(DecimalDegreeCoordinate));
  
  return new DecimalDegreeCoordinate(dd1.lat + dd2.lat, dd1.lon + dd2.lon);
}