C# ile İşlemci bilgilerini elde etmek (CPU Seri No)

Bu örnekte sadece birkaç özellik kullanıldı, örneği inceleyerek diğer özellikleri de elde edebilirsiniz.

Örneği kullanabilmek için System.Management.dll kütüphanesini ve System.Management isim alanını kullanmalısınız.

public Hashtable GetCPUInfo()
{
    Hashtable bilgiler = new Hashtable(); //bilgileri tutacak olan hashtable

    ManagementClass mc = new ManagementClass("Win32_Processor");
    ManagementObjectCollection moc = mc.GetInstances();

    foreach (ManagementObject mo in moc)
    {
        if (bilgiler.Count == 0) //sadece ilk işlemciye ait bilgileri almak istiyoruz
        {
            bilgiler.Add("ID",mo.Properties["ProcessorId"].Value.ToString());
            bilgiler.Add("DeviceID",mo.Properties["DeviceID"].Value.ToString());
            bilgiler.Add("Socket", mo.Properties["SocketDesignation"].Value.ToString());
            bilgiler.Add("Manufacturer", mo.Properties["Manufacturer"].Value.ToString());
        }
        mo.Dispose();
    }

    return bilgiler;
}

public string GetCPUSeriNo()
{
    ManagementClass mc = new ManagementClass("Win32_Processor");
    ManagementObjectCollection moc = mc.GetInstances();

    foreach (ManagementObject mo in moc)
    {
        //sadece ilk işlemciye ait bilgileri almak istiyoruz
        return mo.Properties["ProcessorId"].Value.ToString();
        mo.Dispose();
    }
}

TextBox temizlerken kullandığım genel yöntem

Kod örneğini aşağıda bulabilirsiniz.

public void Temizle(ControlCollection controls)
{
    foreach (Control c in controls)
    {
         if (c is TextBox)
            ((TextBox)c).Text = String.Empty;

        Temizle(c.Controls);
    }
}

The World of Programming

The World of Programming

.NET içerisindeki 5 Temel Tip ve Değer, Referans farkı

.NET 'in 5 temel tipi vardır.
Bunlar Enum , Struct , Interface , Class ve Delegate tipleridir.

Adı geçen tiplerden Enum ve Struct değer türlü olup , diğer 3 tip referans türlüdür.
Değer türlüler belleğin stack bölümünde yer alırken, referans türlüler ise heap bölümünde yer alırlar.

Değer türlüler, datalarını kendi üstlerinde taşırken, referans türlüler veriyi heap bölgesinde tutar ve stack veya heap üzerindeki bir referans (pointer'a benzetebiliriz) ile veriyi işaret ederler. Bu işaretçi işletim sistemine bağlı olarak bellekte 32-bit (4 byte) veya 64-bit (8 byte) yer kaplar.

İki değer türlü arasında atama yapıldığında, verinin yeni bir kopyası çıkartılır ve bir değişken üzerinde yapılan değişiklik diğerini kesinlikle etkilemez. Referans türlüler arasında yapılan atamalarda ise referansın bir kopyası çıkartılır ve iki referans da aynı adresteki datayı işaret ederler. Bu durumda hangi referans üzerinden işlem yapılırsa yapılsın, ortamdaki data tektir ve direkt olarak bir değişken üzerinden yapılan değişiklik , diğeri üzerinden gözlemlenebilir.

The Eight Fallacies of Distributed Computing

Essentially everyone, when they first build a distributed application, makes the following eight assumptions. All prove to be false in the long run and all cause big trouble and painful learning experiences.

1. The network is reliable
2. Latency is zero
3. Bandwidth is infinite
4. The network is secure
5. Topology doesn't change
6. There is one administrator
7. Transport cost is zero
8. The network is homogeneous

Source

Mapping Network Drives using C#

You can use the Windows Networking Functions "WNetAddConnection2" and "WNetCancelConnection2" to map the drives. You can make a connection to a network resource by using the "WNetAddConnection2" function and can cancel an existing network connection by using the "WNetCancelConnection2" function.

Sample file can be downloaded from the following links:
NetworkDriveMapper.cs (Google)
NetworkDriveMapper.cs (Uploading)

---

using System;
using System.Runtime.InteropServices;

namespace Mapping_Network_Drive
{
    public class NetworkDriveMapper
    {
        private enum ResourceScope
        {
            RESOURCE_CONNECTED = 1,
            RESOURCE_GLOBALNET,
            RESOURCE_REMEMBERED,
            RESOURCE_RECENT,
            RESOURCE_CONTEXT
        }

        private enum ResourceType
        {
            RESOURCETYPE_ANY,
            RESOURCETYPE_DISK,
            RESOURCETYPE_PRINT,
            RESOURCETYPE_RESERVED
        }

        private enum ResourceUsage
        {
            RESOURCEUSAGE_CONNECTABLE = 1,
            RESOURCEUSAGE_CONTAINER = 2,
            RESOURCEUSAGE_NOLOCALDEVICE = 4,
            RESOURCEUSAGE_SIBLING = 8,
            RESOURCEUSAGE_ATTACHED = 10
        }

        private enum ResourceDisplayType
        {
            RESOURCEDISPLAYTYPE_GENERIC,
            RESOURCEDISPLAYTYPE_DOMAIN,
            RESOURCEDISPLAYTYPE_SERVER,
            RESOURCEDISPLAYTYPE_SHARE,
            RESOURCEDISPLAYTYPE_FILE,
            RESOURCEDISPLAYTYPE_GROUP,
            RESOURCEDISPLAYTYPE_NETWORK,
            RESOURCEDISPLAYTYPE_ROOT,
            RESOURCEDISPLAYTYPE_SHAREADMIN,
            RESOURCEDISPLAYTYPE_DIRECTORY,
            RESOURCEDISPLAYTYPE_TREE,
            RESOURCEDISPLAYTYPE_NDSCONTAINER
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct NetResource
        {
            public ResourceScope ResourceScope;
            public ResourceType ResourceType;
            public ResourceDisplayType DisplayType;
            public ResourceUsage ResourceUsage;
            public string LocalName;
            public string RemoteName;
            public string Comments;
            public string Provider;
        }

        [DllImport("mpr.dll")]
        private static extern int WNetAddConnection2(ref NetResource networkResource, string password,string userName, int iFlags);

        [DllImport("mpr.dll")]
        private static extern int WNetCancelConnection2(string localName, uint iFlags, int iForce);

        public static void MapNetworkDrive(string driveLetter, string networkPath)
        {
            if (networkPath.EndsWith(@"\")) //When the last character is '\' , this causes error on mapping a drive.
            {
                networkPath = networkPath.Substring(0, networkPath.Length - 1);
            }

            NetResource networkResource = new NetResource();
            networkResource.ResourceType = ResourceType.RESOURCETYPE_DISK;
            networkResource.LocalName = driveLetter + ":";
            networkResource.RemoteName = networkPath;

            //If this drive is currently mapped, first disconnect the mapping before adding the new one
            if (IsDriveMapped(driveLetter))
            {
                DisconnectNetworkDrive(driveLetter, true);
            }

            WNetAddConnection2(ref networkResource, null, null, 0);
        }

        public static int DisconnectNetworkDrive(string driveLetter, bool forceDisconnect)
        {
            if (forceDisconnect)
            {
                return WNetCancelConnection2(driveLetter + ":", 0, 1);
            }
            else
            {
                return WNetCancelConnection2(driveLetter + ":", 0, 0);
            }
        }

        public static bool IsDriveMapped(string driveLetter)
        {
            string[] driveList = Environment.GetLogicalDrives();
            for (int i = 0; i < driveList.Length; i++)
            {
                if (driveLetter + ":\\" == driveList[i].ToString())
                {
                    return true;
                }
            }
            return false;
        }
    }
}