ñêà÷àòü ðåôåðàòû
  RSS    

Ìåíþ

Áûñòðûé ïîèñê

ñêà÷àòü ðåôåðàòû

ñêà÷àòü ðåôåðàòûÊóðñîâàÿ ðàáîòà: Ðàçðàáîòêà ïðîãðàììû "Ôîðìèðîâàíèå è ïðîâåðêà êîíòðîëüíîé ñóììû êëàñòåðîâ"

 }

 ArrayList hdCollection = new ArrayList();

 int Num_Hdd = 0;

 double TotalSize = 0;

 double TotalSpaceLeft = 0;

 bool analiz = false;

 bool OSXP = false;

 private void Form1_Load(object sender, EventArgs e)

 {

 if (MessageBox.Show("Start getting info ?\nThis may take a while, so please stand by.", "Notice", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.No)

 {

 this.Close();

 }

 else

 {

 //AddGeneralinfoTolistview();

 GetHardDiskInfo();

 AddHDDItemToListview();

 }

 }

 

 private void GetHardDiskInfo()

 {

 #region HDD_Collction of Infomation

 hdCollection.Clear();

 Num_Hdd = 0;

 TotalSize = 0;

 TotalSpaceLeft = 0;

 ManagementObjectSearcher searcher = new

 ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");

 foreach (ManagementObject wmi_HD in searcher.Get())

 {

 HardDrive hd = new HardDrive();

 #region hd.Model

 try

 {

 hd.Model = wmi_HD["Model"].ToString();

 }

 catch (Exception)

 {

 hd.Model = "Unknown";

 }

 #endregion

 #region hd.Type

 try

 {

 hd.Type = wmi_HD["InterfaceType"].ToString();

 }

 catch (Exception)

 {

 hd.Type = "Unknown";

 }

 #endregion

 #region hd.BytesPerSector

 try

 {

 hd.BytesPerSector = wmi_HD["BytesPerSector"].ToString();

 }

 catch (Exception)

 {

 hd.BytesPerSector = "Unknown";

 }

 #endregion

 #region hd.MediaType

 try

 {

 hd.MediaType = wmi_HD["MediaType"].ToString();

 }

 catch (Exception)

 {

 hd.MediaType = "Unknown";

 }

 #endregion

 #region hd.Partitions

 try

 {

 hd.Partitions = wmi_HD["Partitions"].ToString();

 }

 catch (Exception)

 {

 hd.Partitions = "Unknown";

 }

 #endregion

 #region hd.SectorsPerTrack

 try

 {

 hd.SectorsPerTrack = wmi_HD["SectorsPerTrack"].ToString();

 }

 catch (Exception)

 {

 hd.SectorsPerTrack = "Unknown";

 }

 #endregion

 #region hd.Signature

 try

 {

 hd.Signature = wmi_HD["Signature"].ToString();

 }

 catch (Exception)

 {

 hd.Signature = "Unknown";

 }

 #endregion

 #region hd.size

 try

 {

 hd.Size = wmi_HD["Size"].ToString();

 }

 catch (Exception)

 {

 hd.Size = "0";

 }

 #endregion

 #region hd.Status

 try

 {

 hd.Status = wmi_HD["Status"].ToString();

 }

 catch (Exception)

 {

 hd.Status = "Unknown";

 }

 #endregion

 #region hd.TotalCylonders

 try

 {

 hd.TotalCylinders = wmi_HD["TotalCylinders"].ToString();

 }

 catch (Exception)

 {

 hd.TotalCylinders = "Unknown";

 }

 #endregion

 #region hd.TotalHeads

 try

 {

 hd.TotalHeads = wmi_HD["TotalHeads"].ToString();

 }

 catch (Exception)

 {

 hd.TotalHeads = "Unknown";

 }

 #endregion

 #region hd.TotalSectors

 try

 {

 hd.TotalSectors = wmi_HD["TotalSectors"].ToString();

 }

 catch (Exception)

 {

 hd.TotalSectors = "Unknown"; }

 #endregion

 #region hd.TotalTracks

 try

 {

 hd.TotalTracks = wmi_HD["TotalTracks"].ToString(); }

 catch (Exception)

 {

 hd.TotalTracks = "Unknown"; }

 #endregion

 #region hd.TracksPerCylinder

 try

 {

 hd.TracksPerCylinder = wmi_HD["TracksPerCylinder"].ToString(); }

 catch (Exception)

 {

 hd.TracksPerCylinder = "Unknown"; }

 #endregion

 #region hd.SeralNo

 if (OSXP != true)

 {

 try

 {

 hd.SerialNo = wmi_HD["SerialNumber"].ToString(); }

 catch (Exception)

 {

 hd.SerialNo = "Unknown";

 } }

 else

 { }

 #endregion

 #region hd.FirmwareRevision

 try

 {

 hd.FirmwareRevision = wmi_HD["FirmwareRevision"].ToString(); }

 catch (Exception)

 {

 hd.FirmwareRevision = " "; }

 #endregion

 hdCollection.Add(hd);

 hd = null;

 Num_Hdd = Num_Hdd + 1;

 TotalSize = TotalSize + double.Parse(wmi_HD["Size"].ToString());

 }

 #region //Getting HDD's serial under XP

 if (OSXP == true)

 {

 searcher = new

 ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");

 int i = 0;

 foreach (ManagementObject wmi_HD in searcher.Get())

 {

 // get the hard drive from collection

 // using index

 HardDrive hd = (HardDrive)hdCollection[i];

 // get the hardware serial no.

 if (wmi_HD["SerialNumber"] == null)

 hd.SerialNo = "None";

 else

 hd.SerialNo = wmi_HD["SerialNumber"].ToString();

 ++i;

 }

 }

 #endregion

 searcher = new

 ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk");

 foreach (ManagementObject wmi_HD in searcher.Get())

 {

 // get how much Freespace the HDD have left...

 if (wmi_HD["FreeSpace"] == null)

 {

 //do nothing

 }

 else

 {

 if (wmi_HD["DriveType"].ToString() == "3")

 {

 TotalSpaceLeft += double.Parse(wmi_HD["FreeSpace"].ToString());

 }

 }

 }

 // HDD_info_Done = true;

 searcher = null;

 #endregion

 }

 private void AddHDDItemToListview()

 {

 //Makes the Search group:::......

 ListViewGroup HDDGroup = new ListViewGroup();

 HDDGroup.Header = "HardDrive(s) :";

 HDDGroup.HeaderAlignment = HorizontalAlignment.Left;

 HDDGroup.Name = "HardDrive(s)";

 //Adds the search group...

 listView1.Groups.Add(HDDGroup);

 int i = 0;

 foreach (HardDrive x in hdCollection)

 {

 AddItemToListview(HDDGroup, i, x.Model.ToString(), 0, "1");

 i++; }

 HDDGroup = null; }

 private void AddItemToListview(ListViewGroup GroupName, int IndexNumber, string ItemName, int ImageIndex, string ItemTAG)

 {

 ListViewItem NewItem = new ListViewItem();

 ListViewItem.ListViewSubItem NewSubItem = new ListViewItem.ListViewSubItem();

 NewSubItem.Text = IndexNumber.ToString();

 NewSubItem.Name = "Subitem1";

 NewItem.SubItems.Add(NewSubItem);

 NewItem.SubItems.Add(NewSubItem);

 NewItem.Name = ItemName;

 NewItem.Text = ItemName;

 NewItem.Group = GroupName;

 NewItem.ImageIndex = ImageIndex;

 NewItem.Tag = ItemTAG;

 listView1.Items.Add(NewItem);

 NewItem = null;

 NewSubItem = null;

 // Group = null; }

 private void WriteHDDText()

 {

 HardDrive Hd = null;

 bool fail = false;

 try

 {

 Hd = (HardDrive)hdCollection[int.Parse(listView1.SelectedItems[0].SubItems[1].Text)]; }

 catch (Exception)

 {

 Hd = null;

 fail = true; }

 if (fail != true)

 {

 Hd = (HardDrive)hdCollection[int.Parse(listView1.SelectedItems[0].SubItems[1].Text)];

 double size_temp = double.Parse(Hd.Size);

 if (analiz == false)

 {

 richTextBox1.Clear();

 richTextBox1.Text = ("\n" +

 "Model:\n" +

 "--------------------------------------------------------\n" +

 "Model : " + Hd.Model.ToString() + "\n" +

 "Type : " + Hd.Type.ToString() + "\n" +

 "Serial No. : " + Hd.SerialNo.ToString() + "\n" +

 "Firmware Revision : " + Hd.FirmwareRevision.ToString() + "\n" +

 "\n" +

 "Characteristics:\n" +

 "--------------------------------------------------------\n" +

 "Media Type : " + Hd.MediaType.ToString() + "\n" +

 "Partitions : " + Hd.Partitions.ToString() + "\n" +

 "Signature : " + Hd.Signature.ToString() + "\n" +

 "Size : " + Hd.Size.ToString() + " Byte (" + Math.Round((((size_temp / 1024) / 1024) / 1024), 2) + " GB)" + "\n" +

 "\n" +

 "Status : " + Hd.Status.ToString() + "\n" +

 "\n" +

 "Tracks:\n" +

 "--------------------------------------------------------\n" +

 "Total Cylinders : " + Hd.TotalCylinders.ToString() + "\n" +

 "Total Heads : " + Hd.TotalHeads.ToString() + "\n" +

 "Total Sectors : " + Hd.TotalSectors.ToString() + "\n" +

 "Total Tracks : " + Hd.TotalTracks.ToString() + "\n" +

 "Bytes Pr. Sector : " + Hd.BytesPerSector.ToString() + "\n" +

 "Sector Pr. Tracks : " + Hd.SectorsPerTrack.ToString() + "\n" +

 "Tracks Pr. Cylinder : " + Hd.TracksPerCylinder.ToString() + "\n"

 ); }

 else

 {

 richTextBox2.Clear();

 richTextBox2.Text = ("\n" +

 "Model:\n" +

 "--------------------------------------------------------\n" +

 "Model : " + Hd.Model.ToString() + "\n" +

 "Type : " + Hd.Type.ToString() + "\n" +

 "Serial No. : " + Hd.SerialNo.ToString() + "\n" +

 "Firmware Revision : " + Hd.FirmwareRevision.ToString() + "\n" +

 "\n" +

 "Characteristics:\n" +

 "--------------------------------------------------------\n" +

 "Media Type : " + Hd.MediaType.ToString() + "\n" +

 "Partitions : " + Hd.Partitions.ToString() + "\n" +

 "Signature : " + Hd.Signature.ToString() + "\n" +

 "Size : " + Hd.Size.ToString() + " Byte (" + Math.Round((((size_temp / 1024) / 1024) / 1024), 2) + " GB)" + "\n" +

 "\n" +

 "Status : " + Hd.Status.ToString() + "\n" +

 "\n" +

 "Tracks:\n" +

 "--------------------------------------------------------\n" +

 "Total Cylinders : " + Hd.TotalCylinders.ToString() + "\n" +

 "Total Heads : " + Hd.TotalHeads.ToString() + "\n" +

 "Total Sectors : " + Hd.TotalSectors.ToString() + "\n" +

 "Total Tracks : " + Hd.TotalTracks.ToString() + "\n" +

 "Bytes Pr. Sector : " + Hd.BytesPerSector.ToString() + "\n" +

 "Sector Pr. Tracks : " + Hd.SectorsPerTrack.ToString() + "\n" +

 "Tracks Pr. Cylinder : " + Hd.TracksPerCylinder.ToString() + "\n"

 ); }

 size_temp = 0;

 }

 Hd = null;

 }

 private void listView1_SelectedIndexChanged(object sender, EventArgs e)

 {

 int selected_index;

 try

 {

 //MessageBox.Show(listView1.SelectedItems[0].Tag.ToString());

 selected_index = listView1.SelectedItems[0].Index;

 switch (listView1.SelectedItems[0].Tag.ToString())

 {

 case "1":

 WriteHDDText();

 break;

 } }

 catch (Exception)

 {

 //Do nothing

 } }

 private void button1_Click(object sender, EventArgs e)

 {

 if (analiz == false)

 analiz = true;

 else

 analiz = false;

 GetHardDiskInfo();

 WriteHDDText();

 }

 private void button2_Click(object sender, EventArgs e)

 {

 Form2 f2 = new Form2();

 f2.Show();

 }

 }

}

//Form2.cs

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.IO;

using System.Collections;

namespace kurs_pogulyat

{

 public partial class Form2 : Form

 {

 public Form2()

 {

 InitializeComponent();

 }

 //CRC 32

 private void button1_Click(object sender, EventArgs e)

 {

 

 // ×èòàåì ôàéë test.txt

 System.IO.FileStream stream1 = System.IO.File.OpenRead(textBox1.Text.ToString());

                           

 textBox3.Text=(string.Format("{0:X}", CalculateCRC(stream1))).ToString();

 }

                   /// <summary>

                   /// Âû÷èñëåíèå CRC32

                   /// </summary>

                   /// <param name="stream"></param>

                   /// <returns></returns>

                   public static uint CalculateCRC(System.IO.Stream stream)

                   {

                            const int buffer_size = 1024;

                            const uint POLYNOMIAL = 0xEDB88320;

 

                            uint result = 0xFFFFFFFF;

                            uint Crc32;

                            byte[] buffer = new byte[buffer_size];

                            uint[] table_CRC32 = new uint[256];

                            unchecked

                            {

                                      // Èíèöèàëèàçàöèÿ òàáëèöû

                                      for (int i = 0; i < 256; i++)

                                      {

                                               Crc32 = (uint)i;

 

                                               for (int j = 8; j > 0; j--)

                                               {

                                                        if ((Crc32 & 1)==1)

                                                                  Crc32 = (Crc32 >> 1) ^ POLYNOMIAL;

                                                        else

                                                                  Crc32 >>= 1;

                                               }

                                               table_CRC32[i] = Crc32;

                                      }

 /

                                      // ×òåíèå èç áóôåðà

                                      int count = stream.Read(buffer, 0, buffer_size);

                                      // Âû÷èñëåíèå CRC

                                      while (count > 0)

                                      {

                                               for (int i = 0; i < count; i++)

                                               {

                                                        result = ((result) >> 8)

                                                                  ^ table_CRC32[(buffer[i])

                                                                  ^ ((result) & 0x000000FF)];

                                               }

                                               count = stream.Read(buffer, 0, buffer_size);

                                      }

                            }

 

                            return ~result;

                   }

 //MD5

 private void button2_Click(object sender, EventArgs e)

 {

 textBox4.Text = MD5File(textBox2.Text.ToString()).ToString();

 }

 //ñòàòè÷åñêèå ïåðåìåííûå

 private static UInt32 A;

 private static UInt32 B;

 private static UInt32 C;

 private static UInt32 D;

 

 //íîìåð áèòà ñäâèã

 private const int S11 = 7;

 private const int S12 = 12;

 private const int S13 = 17;

 private const int S14 = 22;

 private const int S21 = 5;

 private const int S22 = 9;

 private const int S23 = 14;

 private const int S24 = 20;

 private const int S31 = 4;

 private const int S32 = 11;

 private const int S33 = 16;

 private const int S34 = 23;

 private const int S41 = 6;

 private const int S42 = 10;

 private const int S43 = 15;

 private const int S44 = 21;

 /* ñäâèãè

 r[ 0..15] := {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22}

 r[16..31] := {5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20}

 r[32..47] := {4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23}

 r[48..63] := {6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21}*/

 /* F, G, H è I îñíîâíûå ôóíêöèè àëãîðèòìà âû÷èñëåíèÿ MD5

 F(X,Y,Z) =(X&Y)|((~X)&Z)

 G(X,Y,Z) =(X&Z)|(Y&(~Z))

 H(X,Y,Z) =X^Y^Z

 I(X,Y,Z)=Y^(X|(~Z))

 */

 private static UInt32 F(UInt32 x, UInt32 y, UInt32 z)

 

 

 private static UInt32 G(UInt32 x, UInt32 y, UInt32 z)

 

 private static UInt32 H(UInt32 x, UInt32 y, UInt32 z)

 {

 return x ^ y ^ z;

 }

 private static UInt32 I(UInt32 x, UInt32 y, UInt32 z)

 

 

 // FF, GG, HH, è II ïðåîáðàçîàíèÿ äëÿ ðàóíäîâ 1, 2, 3, è 4.

 

 private static void FF(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)

 

 a = a << s

 private static void GG(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)

 

 private static void HH(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)

 

 

 private static void II(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)

 

 

 private static void MD5_Init()

 {

 A = 0x67452301; //â ïàìÿòè 0x01234567

 B = 0xefcdab89; //â ïàìÿòè, 0x89abcdef

 C = 0x98badcfe; //â ïàìÿòè, 0xfedcba98

 D = 0x10325476; //â ïàìÿòè, 0x76543210

 }

 

 private static UInt32[] MD5_Append(byte[] input)

 {

 int zeros = 0;

 int ones = 1;

 int size = 0;

 int n = input.Length;

 int m = n % 64; //îñòàòîê îò äåëåíèÿ

 if (m < 56)

 {

 zeros = 55 - m;

 size = n - m + 64;

 }

 else

 {

 zeros = 63 - m + 56;

 size = n + 64 - m + 64;

 }

 

 ArrayList bs = new ArrayList(input);

 if (ones == 1)

 {

 bs.Add((byte)0x80); // 0x80 = $10000000

 }

 for (int i = 0; i < zeros; i++)

 {

 bs.Add((byte)0);

 }

 

 UInt64 N = (UInt64)n * 8;

 byte h1 = (byte)(N & 0xFF);

 byte h2 = (byte)((N >> 8) & 0xFF);

 byte h3 = (byte)((N >> 16) & 0xFF);

 byte h4 = (byte)((N >> 24) & 0xFF);

 byte h5 = (byte)((N >> 32) & 0xFF);

 byte h6 = (byte)((N >> 40) & 0xFF);

 byte h7 = (byte)((N >> 48) & 0xFF);

 byte h8 = (byte)(N >> 56);

 bs.Add(h1);

 bs.Add(h2);

 bs.Add(h3);

 bs.Add(h4);

 bs.Add(h5);

 bs.Add(h6);

 bs.Add(h7);

 bs.Add(h8);

 byte[] ts = (byte[])bs.ToArray(typeof(byte));

 

 // Äåêîäèíã input (byte[]) â output (UInt32[])

 

 UInt32[] output = new UInt32[size / 4];

 for (Int64 i = 0, j = 0; i < size; j++, i += 4)

 

 return output;

 }

 

 private static UInt32[] MD5_Trasform(UInt32[] x)

 {

 

 UInt32 a, b, c, d;

 

 for (int k = 0; k < x.Length; k += 16)

 {

 a = A;

 b = B;

 c = C;

 d = D;

 

 /* Ðàóíä1 */

 FF(ref a, b, c, d, x[k + 0], S11, 0xd76aa478); /* 1 */

 FF(ref d, a, b, c, x[k + 1], S12, 0xe8c7b756); /* 2 */

 FF(ref c, d, a, b, x[k + 2], S13, 0x242070db); /* 3 */

 FF(ref b, c, d, a, x[k + 3], S14, 0xc1bdceee); /* 4 */

 FF(ref a, b, c, d, x[k + 4], S11, 0xf57c0faf); /* 5 */

 FF(ref d, a, b, c, x[k + 5], S12, 0x4787c62a); /* 6 */

 FF(ref c, d, a, b, x[k + 6], S13, 0xa8304613); /* 7 */

 FF(ref b, c, d, a, x[k + 7], S14, 0xfd469501); /* 8 */

 FF(ref a, b, c, d, x[k + 8], S11, 0x698098d8); /* 9 */

 FF(ref d, a, b, c, x[k + 9], S12, 0x8b44f7af); /* 10 */

 FF(ref c, d, a, b, x[k + 10], S13, 0xffff5bb1); /* 11 */

 FF(ref b, c, d, a, x[k + 11], S14, 0x895cd7be); /* 12 */

 FF(ref a, b, c, d, x[k + 12], S11, 0x6b901122); /* 13 */

 FF(ref d, a, b, c, x[k + 13], S12, 0xfd987193); /* 14 */

 FF(ref c, d, a, b, x[k + 14], S13, 0xa679438e); /* 15 */

 FF(ref b, c, d, a, x[k + 15], S14, 0x49b40821); /* 16 */

 

 /* Ðàóíä2 */

 GG(ref a, b, c, d, x[k + 1], S21, 0xf61e2562); /* 17 */

 GG(ref d, a, b, c, x[k + 6], S22, 0xc040b340); /* 18 */

 GG(ref c, d, a, b, x[k + 11], S23, 0x265e5a51); /* 19 */

 GG(ref b, c, d, a, x[k + 0], S24, 0xe9b6c7aa); /* 20 */

 GG(ref a, b, c, d, x[k + 5], S21, 0xd62f105d); /* 21 */

 GG(ref d, a, b, c, x[k + 10], S22, 0x2441453); /* 22 */

 GG(ref c, d, a, b, x[k + 15], S23, 0xd8a1e681); /* 23 */

 GG(ref b, c, d, a, x[k + 4], S24, 0xe7d3fbc8); /* 24 */

 GG(ref a, b, c, d, x[k + 9], S21, 0x21e1cde6); /* 25 */

 GG(ref d, a, b, c, x[k + 14], S22, 0xc33707d6); /* 26 */

 GG(ref c, d, a, b, x[k + 3], S23, 0xf4d50d87); /* 27 */

 GG(ref b, c, d, a, x[k + 8], S24, 0x455a14ed); /* 28 */

 GG(ref a, b, c, d, x[k + 13], S21, 0xa9e3e905); /* 29 */

 GG(ref d, a, b, c, x[k + 2], S22, 0xfcefa3f8); /* 30 */

 GG(ref c, d, a, b, x[k + 7], S23, 0x676f02d9); /* 31 */

 GG(ref b, c, d, a, x[k + 12], S24, 0x8d2a4c8a); /* 32 */

 

 /* Ðàóíä3 */

 HH(ref a, b, c, d, x[k + 5], S31, 0xfffa3942); /* 33 */

 HH(ref d, a, b, c, x[k + 8], S32, 0x8771f681); /* 34 */

 HH(ref c, d, a, b, x[k + 11], S33, 0x6d9d6122); /* 35 */

 HH(ref b, c, d, a, x[k + 14], S34, 0xfde5380c); /* 36 */

 HH(ref a, b, c, d, x[k + 1], S31, 0xa4beea44); /* 37 */

 HH(ref d, a, b, c, x[k + 4], S32, 0x4bdecfa9); /* 38 */

 HH(ref c, d, a, b, x[k + 7], S33, 0xf6bb4b60); /* 39 */

 HH(ref b, c, d, a, x[k + 10], S34, 0xbebfbc70); /* 40 */

 HH(ref a, b, c, d, x[k + 13], S31, 0x289b7ec6); /* 41 */

 HH(ref d, a, b, c, x[k + 0], S32, 0xeaa127fa); /* 42 */

 HH(ref c, d, a, b, x[k + 3], S33, 0xd4ef3085); /* 43 */

 HH(ref b, c, d, a, x[k + 6], S34, 0x4881d05); /* 44 */

 HH(ref a, b, c, d, x[k + 9], S31, 0xd9d4d039); /* 45 */

 HH(ref d, a, b, c, x[k + 12], S32, 0xe6db99e5); /* 46 */

 HH(ref c, d, a, b, x[k + 15], S33, 0x1fa27cf8); /* 47 */

 HH(ref b, c, d, a, x[k + 2], S34, 0xc4ac5665); /* 48 */

 

 /* Ðàóíä4 */

 II(ref a, b, c, d, x[k + 0], S41, 0xf4292244); /* 49 */

 II(ref d, a, b, c, x[k + 7], S42, 0x432aff97); /* 50 */

 II(ref c, d, a, b, x[k + 14], S43, 0xab9423a7); /* 51 */

 II(ref b, c, d, a, x[k + 5], S44, 0xfc93a039); /* 52 */

 II(ref a, b, c, d, x[k + 12], S41, 0x655b59c3); /* 53 */

 II(ref d, a, b, c, x[k + 3], S42, 0x8f0ccc92); /* 54 */

 II(ref c, d, a, b, x[k + 10], S43, 0xffeff47d); /* 55 */

 II(ref b, c, d, a, x[k + 1], S44, 0x85845dd1); /* 56 */

 II(ref a, b, c, d, x[k + 8], S41, 0x6fa87e4f); /* 57 */

 II(ref d, a, b, c, x[k + 15], S42, 0xfe2ce6e0); /* 58 */

 II(ref c, d, a, b, x[k + 6], S43, 0xa3014314); /* 59 */

 II(ref b, c, d, a, x[k + 13], S44, 0x4e0811a1); /* 60 */

 II(ref a, b, c, d, x[k + 4], S41, 0xf7537e82); /* 61 */

 II(ref d, a, b, c, x[k + 11], S42, 0xbd3af235); /* 62 */

 II(ref c, d, a, b, x[k + 2], S43, 0x2ad7d2bb); /* 63 */

 II(ref b, c, d, a, x[k + 9], S44, 0xeb86d391); /* 64 */

 

 A += a;

 B += b;

 C += c;

 D += d;

 }

 return new UInt32[] { A, B, C, D };

 }

 private static byte[] MD5Array(byte[] input)

 {

 MD5_Init();

 UInt32[] block = MD5_Append(input);

 UInt32[] bits = MD5_Trasform(block);

 

 // Êîäèðóåò bits (UInt32[]) â output (byte[]).

 byte[] output = new byte[bits.Length * 4];

 for (int i = 0, j = 0; i < bits.Length; i++, j += 4)

 {

 output[j] = (byte)(bits[i] & 0xff);

 output[j + 1] = (byte)((bits[i] >> 8) & 0xff);

 output[j + 2] = (byte)((bits[i] >> 16) & 0xff);

 output[j + 3] = (byte)((bits[i] >> 24) & 0xff);

 }

 return output;

 }

 private static string ArrayToHexString(byte[] array, bool uppercase)

 {

 string hexString = "";

 string format = "x2";

 if (uppercase)

 {

 format = "X2";

 }

 foreach (byte b in array)

 {

 hexString += b.ToString(format);

 }

 return hexString;

 }

 private static string MD5File(string fileName)

 {

 FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.Read);

 byte[] array = new byte[fs.Length];

 fs.Read(array, 0, (int)fs.Length);

 byte[] digest = MD5Array(array);

 fs.Close();

 return ArrayToHexString(digest, false);

 }

 }

}

//HardDrive.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace kurs_pogulyat

{

 class HardDrive

 {

 private string model = "";

 private string type = "";

 private string serialNo = "";

 private string bytesPerSector = "";

 private string mediaType = "";

 private string partitions = "";

 private string sectorsPerTrack = "";

 private string signature = "";

 private string size = "";

 private string freespace = "";

 private string status = "";

 private string totalCylinders = "";

 private string totalHeads = "";

 private string totalSectors = "";

 private string totalTracks = "";

 private string tracksPerCylinder = "";

 private string firmwareRevision = "";

 public string Model

 {

 get { return model; }

 set { model = value; }

 }

 public string Type

 {

 get { return type; }

 set { type = value; }

 }

 public string SerialNo

 {

 get { return serialNo; }

 set { serialNo = value; }

 }

 public string BytesPerSector

 {

 get { return bytesPerSector; }

 set { bytesPerSector = value; }

 }

 public string MediaType

 {

 get { return mediaType; }

 set { mediaType = value; }

 }

 public string Partitions

 {

 get { return partitions; }

 set { partitions = value; }

 }

 public string SectorsPerTrack

 {

 get { return sectorsPerTrack; }

 set { sectorsPerTrack = value; }

 }

 public string Signature

 {

 get { return signature; }

 set { signature = value; }

 }

 public string Size

 {

 get { return size; }

 set { size = value; }

 }

 public string FreeSpace

 {

 get { return freespace; }

 set { freespace = value; }

 }

 public string Status

 {

 get { return status; }

 set { status = value; }

 }

 public string TotalCylinders

 {

 get { return totalCylinders; }

 set { totalCylinders = value; }

 }

 public string TotalHeads

 {

 get { return totalHeads; }

 set { totalHeads = value; }

 }

 public string TotalSectors

 {

 get { return totalSectors; }

 set { totalSectors = value; }

 }

 public string TotalTracks

 {

 get { return totalTracks; }

 set { totalTracks = value; }

 }

 public string TracksPerCylinder

 {

 get { return tracksPerCylinder; }

 set { tracksPerCylinder = value; }

 }

 public string FirmwareRevision

 {

 get { return firmwareRevision; }

 set { firmwareRevision = value; }

 } }

}

//Program.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Windows.Forms;

namespace kurs_pogulyat

{

 static class Program

 {

 [STAThread]

 static void Main()

 {

 Application.EnableVisualStyles();

 Application.SetCompatibleTextRenderingDefault(false);

 Application.Run(new Form1());

 }

 }

}


Ñòðàíèöû: 1, 2, 3


Íîâîñòè

Áûñòðûé ïîèñê

Ãðóïïà âÊîíòàêòå: íîâîñòè

Ïîêà íåò

Íîâîñòè â Twitter è Facebook

  ñêà÷àòü ðåôåðàòû              ñêà÷àòü ðåôåðàòû

Íîâîñòè

ñêà÷àòü ðåôåðàòû

Îáðàòíàÿ ñâÿçü

Ïîèñê
Îáðàòíàÿ ñâÿçü
Ðåêëàìà è ðàçìåùåíèå ñòàòåé íà ñàéòå
© 2010.