Tekil Bilgisayar Id’si Üretme

Aşağıdaki metot yardımı ile tekil bilgisayar id’si üretip, bunu bilgisayarı tanımlamak için kullanabiliriz. Aşağıdaki kod işlemci, anakart ve sabit disk üzerinden id’yi oluşturmaktadır. Bu numaraları birleştirip SHA-512 hashini hesaplıyoruz ve bu şekilde oluşan id’nin her zaman 128 karakter olmasını garantilemiş oluyoruz. Donanım numaralarını basit bir şekilde birleştirmek yerine byte[] dönüşümü yapıp, toplama, and, or, xor, bit kaydırma gibi daha karmaşık yöntemler kullanılırsa güvenlik daha da artacaktır.

public static string GenerateHardwareId()
{
     // gets processor id
     string pId = "";
     var mos = new ManagementObjectSearcher("select * from Win32_Processor");

     foreach (ManagementObject m in mos.Get())
     {
         pId = m["ProcessorId"].ToString();
         break;
     }

     // gets motherboard id
     string mbId = "";
     mos = new ManagementObjectSearcher("select * from Win32_BaseBoard");

     foreach (ManagementObject m in mos.Get())
     {
         mbId = m["SerialNumber"].ToString();
         break;
     }

     // gets logical disk volume serial number
     string ldvSerialNumber = "";
     mos = new ManagementObjectSearcher("select * from Win32_LogicalDisk");

     foreach (ManagementObject m in mos.Get())
     {
         if (m["DeviceID"].ToString() == "C:")
         {
             ldvSerialNumber = m["VolumeSerialNumber"].ToString();
             break;
         }
     }

     var hwIdJoined = ldvSerialNumber + pId + mbId;

     byte[] hash = new SHA512Managed().ComputeHash(Encoding.UTF8.GetBytes(hwIdJoined));

     return BitConverter.ToString(hash).Replace("-", "").ToLower();      
}

Yerel Wsdl Dosyasından Web Servis Bağlantısı İçin Kod Üretme

Wsdl.exe aracı ile XML web servislerini kullanmak için kod üretebiliriz.

Wsdl adresi tarayıcıda açılır. Doküman bir dizine x.wsdl olarak kaydedilir.
Dokümandaki xsd adresi alınır. Tarayıcıda açılır ve önceki dizine x.xsd olarak kaydedilir.
Visual Studio komut satırı yönetici olarak başlatılır. Aşağıdaki komut çalıştırılır.

wsdl /verbose <wsdl dosya yolu> <xsd dosya yolu>

Aynı dizinde cs uzantılı dosyamız oluşacaktır. Projeye ekleyip kullanabiliriz.

Windows Makinelerde Program Yüklü mü Kontrolü

Aşağıdaki methot ile Windows işletim sisteminde herhangi bir programın yüklü olup olmadığını kontrol edebiliriz. Sadece “Program Ekle Kaldır” da görünen adı ile veya isteniyorsa sürüm numarasını da parametre olarak girip sorgulama yapabiliyoruz.


private bool IsProgramInstalled(string displayName, string displayVersion = null)
 {
 var uninstallKey = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall";

using (var registryKey = Registry.LocalMachine.OpenSubKey(uninstallKey))
 {
 foreach (var subKeyName in registryKey.GetSubKeyNames())
 {
 using (var subKey = registryKey.OpenSubKey(subKeyName))
 {
 var dn = subKey.GetValue("DisplayName");

if ((dn != null) && (dn.ToString() == displayName))
 {
 if (displayVersion != null)
 {
 var dv = subKey.GetValue("DisplayVersion");

return (dv != null) && (dv.ToString() == displayVersion);
 }

return true;
 }
 }

}
 }

return false;
 }

Küçük Bellek Dökümü(MiniDump) Alma

Aşağıdaki sınıf ile kod içinde herhangi bir anda küçük bellek dökümü alıp dosyaya kaydedebilirsiniz.

using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;

namespace MiniDumper
{
    public class MiniDumper
    {
        internal enum MINIDUMP_TYPE
        {
            MiniDumpNormal = 0x00000000,
            MiniDumpWithDataSegs = 0x00000001,
            MiniDumpWithFullMemory = 0x00000002,
            MiniDumpWithHandleData = 0x00000004,
            MiniDumpFilterMemory = 0x00000008,
            MiniDumpScanMemory = 0x00000010,
            MiniDumpWithUnloadedModules = 0x00000020,
            MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
            MiniDumpFilterModulePaths = 0x00000080,
            MiniDumpWithProcessThreadData = 0x00000100,
            MiniDumpWithPrivateReadWriteMemory = 0x00000200,
            MiniDumpWithoutOptionalData = 0x00000400,
            MiniDumpWithFullMemoryInfo = 0x00000800,
            MiniDumpWithThreadInfo = 0x00001000,
            MiniDumpWithCodeSegs = 0x00002000
        }

        [DllImport("dbghelp.dll")]
        static extern bool MiniDumpWriteDump(IntPtr hProcess, 
                                             Int32 ProcessId,
                                             IntPtr hFile,
                                             MINIDUMP_TYPE DumpType,
                                             IntPtr ExceptionParam,
                                             IntPtr UserStreamParam,
                                             IntPtr CallackParam);

        public static void MiniDumpToFile(string fileToDump)
        {
            FileStream fs = null;

            if (File.Exists(fileToDump))
            {
                fs = File.Open(fileToDump, FileMode.Append);
            }
            else
            {
                fs = File.Create(fileToDump);
            }

            var thisProcess = Process.GetCurrentProcess();

            MiniDumpWriteDump(thisProcess.Handle, 
                              thisProcess.Id, 
                              fs.SafeFileHandle.DangerousGetHandle(), 
                              MINIDUMP_TYPE.MiniDumpNormal, 
                              IntPtr.Zero, 
                              IntPtr.Zero, 
                              IntPtr.Zero);
            
            fs.Close();
        }
    }
}

Dinamik Olarak Dll Yükleme ve Kullanma

.NET ile yazılmış bir dll’i projeye eklemeden, dosya yolunu göstererek kullanabiliriz. Aşağıdaki örnek için çağırılacak sınıf ve metot statik olmalıdır.

using System;
using System.IO;
using System.Reflection;

namespace DynamicLoadTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var result = CallMethod(@&quot;C:\SampleDll.dll&quot;, &quot;Add&quot;, new object[] { 5, 4 });

            if (result is Exception)
            {
                Console.WriteLine(&quot;Some errors occured!&quot;);

                Console.ReadKey();
            }

            Console.WriteLine(result);

            Console.ReadKey();
        }

        private static object CallMethod(string assemblyFile, string methodName, object[] parameters)
        {
            try
            {
                var a = Assembly.LoadFrom(assemblyFile);

                var mi = a.GetTypes()[0].GetMethod(methodName);

                return mi.Invoke(null, parameters);
            }
            catch (Exception ex)
            {
                return ex;
            }
        }
    }
}

Yukarıdaki yöntem çok esnek bir yöntem değil. Methot adlarını bilmek gerekiyor. Bunun yerine .NET kütüphanesinde bulunan MEF(Managed Extensibility Framework) kütüphanesini kullanabiliriz. Bu kütüphane System.Composition altında bulunmaktadır.

Bir interface oluşturulur.

namespace CompositionTest
{
    public interface IOperation
    {
        int Add(int a, int b);

        int Subtract(int a, int b);

        double Divide(int a, int b);

        int Multiply(int a, int b);
    }
}

Interface’de kullanmak için modül tipi metadata’sı oluşturulur.

namespace CompositionTest
{
    public interface IOperationMetadata
    {
        ModuleTypes ModuleType { get; }
    }
}

MEF kütüphanesini kullanmak için yardımcı bir sınıf oluşturulur.

using DynamicLoadTest;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.IO;
using System.Reflection;

namespace CompositionTest
{
    public class MefHelper
    {
        [ImportMany]
        public IEnumerable&lt;Lazy&lt;IOperation, IOperationMetadata&gt;&gt; operations;

        public void Setup()
        {
            try
            {
                operations = new List&lt;Lazy&lt;IOperation, IOperationMetadata&gt;&gt;();

                var aggregate = new AggregateCatalog();
                //aggregate.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));
                aggregate.Catalogs.Add(new DirectoryCatalog(Path.GetDirectoryName(Assembly.GetAssembly(typeof(Program)).Location)));

                var parts = new CompositionBatch();
                parts.AddPart(this);

                var container = new CompositionContainer(aggregate);
                container.Compose(parts);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
            }
        }
    }
}

Modül tipleri enum’u oluşturulur.

namespace CompositionTest
{
    public enum ModuleTypes
    {
        None, AnotherModule, SampleModule
    }
}

Aşağıdaki gibi kullanabiliriz.

using CompositionTest;
using System;
using System.Linq;

namespace DynamicLoadTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var mh = new MefHelper();

            mh.Setup();

            Console.WriteLine(mh.operations.First(f =&gt; f.Metadata.ModuleType == ModuleTypes.AnotherModule).Value.Add(10, 4));

            Console.WriteLine(mh.operations.First(f =&gt; f.Metadata.ModuleType == ModuleTypes.SampleModule).Value.Add(10, 4));

            Console.ReadKey();

            Console.WriteLine(mh.operations.First(f =&gt; f.Metadata.ModuleType == ModuleTypes.AnotherModule).Value.Add(10, 4));

            Console.WriteLine(mh.operations.First(f =&gt; f.Metadata.ModuleType == ModuleTypes.SampleModule).Value.Add(10, 4));

            Console.ReadKey();
        }
    }
}

Örnek dll sınıfı.

using CompositionTest;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AnotherModule
{
    [Export(typeof(IOperation))]
    [ExportMetadata(&quot;ModuleType&quot;, ModuleTypes.AnotherModule)]
    public class Operation : IOperation
    {
        public int Add(int a, int b)
        {
            return -1;
        }

        public int Subtract(int a, int b)
        {
            return -2;
        }

        public double Divide(int a, int b)
        {
            return -3;
        }

        public int Multiply(int a, int b)
        {
            return -4;
        }
    }
}

Örnek projeyi buradan indirebilirsiniz.

Linq ile Gruplama

.NET’te yer alan ve bence en kullanışlı teknolojilerden biri olan Linq kütüphanesi ile istediğimiz koleksiyon gruplamak çok kolaydır.

Tek kolona göre gruplama:

var groupedCustomers = Customers.GroupBy(f => f.City);

Birden fazla kolona göre gruplama:

var groupedCustomers = Customers.GroupBy(f => new { f.City, f.Country });

Olay Tabanlı Asenkron Metotları “Task” Tabanlı Hale Getirme

.NET 4.5 ile gelen ve asenkron programlamayı oldukça kolaylaştıran “await” komutunu kullanabilmek için metodumuzun “Task” tabanlı olması gerekmekte. Aşağıdaki örnekteki gibi bunu başarabiliyoruz.

Olay Tabanlı Metot:

public void DoSomeAsyncJob(string someInput, Action<bool> onCompleted){}

“Task” Tabanlı Metot:

public Task<bool> DoSomeAsyncJob(string someInput)
{
     var t = new TaskCompletionSource<bool>();

     DoSomeAsyncJob(someInput, f => t.TrySetResult(f));

     return t.Task;
}

AES Şifreleme ve Çözme

AES (Advanced Encryption Standard; Gelişmiş Şifreleme Standardı), elektronik verinin şifrelenmesi için sunulan bir standarttır. Amerikan Hükümeti tarafından kabul edilen AES, uluslararası alanda da defacto şifreleme (kripto) standardı olarak kullanılmaktadır.
AES ile standartlaştırılan algoritma, esas olarak Vincent Rijmen ve Joan Daemen tarafından geliştirilen Rijndael algoritmasında bazı değişiklikler yapılarak oluşturulmuştur. Rijndael, geliştiricilerin isimleri kullanılarak elde edilen bir isimdir: RIJmen aNd DAEmen.
256-bit anahtar uzunluğuna sahip AES algoritması için 2200 işlem gerektiren bir saldırı algoritmanın kırılması olarak kabul edilirken, 2200 mertebesindeki bir işlem, şu an için, evrenin yaşından daha uzun bir süre gerektirmektedir.

using System;
using System.IO;
using System.Security.Cryptography;

namespace AES
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                var text = "TeSt";

                using (var myRijndael = new RijndaelManaged())
                {
                    var key = myRijndael.Key;
                    var IV = myRijndael.IV;

                    Console.WriteLine("Original:   {0}", text);

                    var encrypted = EncryptStringToBytes(text, key, IV);

                    Console.WriteLine("Encrypted:   {0}", Convert.ToBase64String(encrypted));

                    var decrypted = DecryptStringFromBytes(encrypted, key, IV);

                    Console.WriteLine("Decrypted:   {0}", decrypted);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
            }

            Console.ReadKey();
        }

        static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
        {
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");

            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");

            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            byte[] encrypted;

            using (var rijAlg = new RijndaelManaged())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                var encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);

                using (var msEncrypt = new MemoryStream())
                {
                    using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (var swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(plainText);
                        }

                        encrypted = msEncrypt.ToArray();
                    }
                }
            }

            return encrypted;
        }

        static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV)
        {
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");

            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");

            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            string plaintext = null;

            using (var rijAlg = new RijndaelManaged())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                var decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);

                using (var msDecrypt = new MemoryStream(cipherText))
                {
                    using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (var srDecrypt = new StreamReader(csDecrypt))
                        {
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return plaintext;
        }
    }
}

Basit Şifreleme ve Çözme

static Random r = new Random();

private static string Encode(string text)
{
     var key = r.Next(10000, 34465);

     var chars = text.ToCharArray();

     var encoded = string.Empty;

     for (int i = 0; i < chars.Length; i++)
     {
          encoded += (int)chars[i] + key;
     }

     var randomIndex = r.Next(0, encoded.Length);

     encoded = encoded.Insert(randomIndex, key.ToString());

     encoded += randomIndex;

     return encoded;
}

private static string Decode(string encodedString)
{
     var randomIndexLength = encodedString.Length % 5;

     if (randomIndexLength == 0)
     {
          randomIndexLength = 5;
     }

     var randomIndex = Convert.ToInt32(encodedString.Substring(encodedString.Length - randomIndexLength));

     var key = Convert.ToInt32(encodedString.Substring(randomIndex, 5));

     var encodedBody = encodedString.Substring(0, randomIndex) + encodedString.Substring(randomIndex + 5,  encodedString.Length - randomIndexLength - randomIndex - 5);

     var decodedChars = new char[encodedBody.Length / 5];

     for (int i = 0; i < decodedChars.Length; i++)
     {
          decodedChars[i] += (char)(Convert.ToInt32(encodedBody.Substring(i * 5, 5)) - key);
     }

     return new string(decodedChars);
}