Обучающие курсы:

Обучение профессии "Разработчик C#" + стажировка в Mail.ru
Обучение профессии "Разработчик Python" + трудоустройство
Обучение профессии "Веб-разработчик" + стажировка в Mail.ru


Главная страница
Библиотека (скачать книги)
Скачать софт
Введение в программирование
Стандарты для C++
Уроки по C#
Уроки по Python
HTML
Веб-дизайн
Ассемблер в среде Windows
ActiveX
Javascript
Общее о Линукс
Линукс - подробно
Линукс - новое
Delphi
Паскаль для начинающих
Турбопаскаль
Новости
Партнеры
Наши предложения
Архив новостей





Практический пример. Чтение произвольных файлов в шестнадцатеричном режиме.

Данная программа отображает указанный пользователем файл на экран в шестнадцатеричном виде (а-ля текстовый редактор в FAR'е). Файл считывается в виде массива байт.

using System;
using System.IO;

namespace CSharpApplication.ReadFileInTextMode
{
    // Класс для считывания и отображения файла в 16-чном режиме
    class ReadHexFile
    {
        static void Main(string [] args /* Параметры командной строки */)
        {
            string FileName;

            // Если параметров командной строки нет
            if(args.Length == 0)
            {
                Console.Write("Введите путь к файлу: ");
                FileName = Console.ReadLine();
            }
            else
            {
                FileName = args[0];
            }
            
            FileStream fs = null;
            try
            {
                // Открываем поток на чтение
                fs = new FileStream(FileName, FileMode.Open, 
                                              FileAccess.Read);
            }
            catch(Exception exc)
            {
                // Вывод сообщения об ошибке
                Console.WriteLine(exc.Message);
                return;
            }
            // Выделяем массив под размер файла
            byte [] arr = new byte[fs.Length];
            // Считываем весь файл в массив
            int N = fs.Read(arr, 0, (int)fs.Length);
            // Закрываем поток
            fs.Close();
            
            int i = 0, j = 0, k = 0;
            // Отображаем информацию
            for(i = 0; i < N; i += 16)
            {
                Console.Write("{0:X8}", i);
                for(j = 0; j < 16 && j + i < N; j++)
                {
                    Console.Write("{0,3:X2}", arr[j + i]);
                }
                
                for(k = 0; k < 17 - j; k++)
                    Console.Write("{0,3}", ' ');

                for(j = 0; j < 16 && j + i < N; j++)
                {
                    // Если управляющий символ
                    if(Char.IsControl((char)arr[j + i]))
                        Console.Write('.');
                    else
                        Console.Write((char)arr[j + i]);
                }
                Console.WriteLine();
            }
        }
    }
}

Практический пример. Чтение и запись двоичных данных.

Данная программа производит запись в файл и чтение из файла двоичных данных. В примере также показан механизм сохранения и загрузки данных класса в (из) файл (-а).

using System;
using System.IO;
using System.Text;

namespace CSharpApplication.ReadWriteBinaryData
{
    // Класс студент
    class Student
    {
        // Имя
        string firstname;
        // Фамилия
        string lastname;
        // Адрес
        string address;
        // Телефон
        string phone;
        // Дата рождения
        DateTime birthday;
        // Номер зачетки
        int number;

        // Свойства
        public string FirstName
        {
            get
            {
                return firstname;
            }
            set
            {
                firstname = value;
            }
        }
        public string LastName
        {
            get
            {
                return lastname;
            }
            set
            {
                lastname = value;
            }
        }
        public string Address
        {
            get
            {
                return address;
            }
            set
            {
                address = value;
            }
        }
        public string Phone
        {
            get
            {
                return phone;
            }
            set
            {
                phone = value;
            }
        }
        public DateTime BirthDay
        {
            get
            {
                return birthday;
            }
            set
            {
                birthday = value;
            }
        }
        public int Number
        {
            get
            {
                return number;
            }
            set
            {
                number = value;
            }
        }
        
        // Поверхностное копирование объекта
        public Student Clone()
        {
            // Вызываем функцию базового класса (Object)
            // для поверхностного копирования объекта
            return (Student)MemberwiseClone();
        }
        // Ввод данных
        public void Input()
        {
            Console.WriteLine("*****Ввод данных о студенте:******");
            Console.Write("Имя: ");
            firstname = Console.ReadLine();
            Console.Write("Фамилия: ");
            lastname = Console.ReadLine();
            Console.Write("Адрес: ");
            address = Console.ReadLine();
            Console.Write("Телефон: ");
            phone = Console.ReadLine();
            Console.Write("Дата рождения: ");
            try
            {
                // Считывание даты
                birthday = Convert.ToDateTime(Console.ReadLine());
            }
            catch
            {
                Console.WriteLine("Ошибка ввода, используем текущую дату");
                birthday = DateTime.Now;
            }
            Console.Write("Номер зачетки: ");
            try
            {
                number = Convert.ToInt32(Console.ReadLine());
            }
            catch
            {
                Console.WriteLine("Ошибка ввода, используется номер 0");
                number = 0;
            }
            Console.WriteLine("**********************************");
        }
        // Вывод данных
        public void Print()
        {
            Console.WriteLine("*****Вывод данных о студенте:*****");
            Console.WriteLine("Имя: {0}", firstname);
            Console.WriteLine("Фамилия: {0}", lastname);
            Console.WriteLine("Адрес: {0}", address);
            Console.WriteLine("Телефон: {0}", phone);
            Console.WriteLine("Дата рождения: {0}.{1}.{2}", 
                birthday.Day, birthday.Month, birthday.Year);
            Console.WriteLine("Номер зачетки: {0}", number);
            Console.WriteLine("**********************************");
        }

        // Запись в файл
        public void Write(BinaryWriter bw)
        {
            // Все данные записываются по отдельности
            bw.Write(firstname);
            bw.Write(lastname);
            bw.Write(address);
            bw.Write(phone);
            bw.Write(birthday.Year);
            bw.Write(birthday.Month);
            bw.Write(birthday.Day);
            bw.Write(number);
        }

        // Статический метод для чтения из файла информации
        // и создания нового объекта на ее основе
        public static Student Read(BinaryReader br)
        {
            // Считывание производится в порядке, 
            // соответствующем записи
            Student st = new Student();
            st.firstname = br.ReadString();
            st.lastname = br.ReadString();
            st.address = br.ReadString();
            st.phone = br.ReadString();
            int year = br.ReadInt32();
            int month = br.ReadInt32();
            int day = br.ReadInt32();
            st.birthday = new DateTime(year, month, day);
            st.number = br.ReadInt32();

            return st;
        }
    }
    // Класс Group
    class Group : ICloneable
    {
        // Название группы
        string groupname;
        // Массив студентов
        Student [] st;

        // Свойства
        public string GroupName
        {
            get
            {
                return groupname;
            }
            set
            {
                groupname = value;
            }
        }
        public Student [] Students
        {
            get
            {
                return st;
            }
            set
            {
                st = value;
            }
        }

        // Конструктор, получающий название группы и количество студентов
        public Group(string gn, int n)
        {
            groupname = gn;
            // По умолчанию в группе 10 студентов
            if(n < 0 || n > 10)
                n = 10;
            st = new Student[n];
            // Создаем студентов
            for(int i = 0; i < n; i++)
                st[i] = new Student();
        }

        // Аналог конструктора копирования
        public Group(Group gr)
        {
            // Создаем массив студентов 
            st = new Student[gr.st.Length];
            // Передираем название группы
            groupname = gr.groupname;
            // Передираем каждого индивидуума
            for(int i = 0; i < gr.st.Length; i++)
                st[i] = gr.st[i].Clone();
        }

        // Заполняем группу
        public void Input()
        {   
            for(int i = 0; i < st.Length; i++)
            {
                Console.WriteLine("{0}.", i + 1);
                st[i].Input();
            }
        }
        // Изменение данных конкретного студента
        public void InputAt(int n)
        {
            if(st == null || n >= st.Length || n < 0)
                return;

            st[n].Input();
        }

        // Вывод списка группы
        public void Print()
        {
            Console.WriteLine("Группа {0}:", groupname);
            
            for(int i = 0; i < st.Length; i++)
            {
                Console.WriteLine("{0}.", i + 1);
                st[i].Print();
            }
        }
        
        // Вывод информации о конкретном студенте
        public void PrintAt(int n)
        {
            if(st == null || n >= st.Length || n < 0)
                return;

            st[n].Print();
        }

        // "Глубокое" копирование,
        // реализация функции из интерфейса IClonable
        public object Clone()
        {
            // Создание новой группы
            Group gr = new Group(groupname, st.Length);
            // Передираем каждого индивидуума
            for(int i = 0; i < st.Length; i++)
                gr.st[i] = st[i].Clone();
            // Возврат независимой копии группы
            return gr;
        }

        // Запись в файл
        public void Write(BinaryWriter bw)
        {
            // Сохраняем название группы
            bw.Write(groupname);
            // Сохраняем количество студентов
            bw.Write(st.Length);
            for(int i = 0; i < st.Length; i++)
                // Для сохранения студента вызывается
                // соответствующий метод из класса Student
                st[i].Write(bw);
        }

        // Статический метод для чтения из файла информации
        // и создания нового объекта на ее основе
        public static Group Read(BinaryReader br)
        {
            string gn = br.ReadString();
            int n = br.ReadInt32();
            
            Student [] st = new Student[n];

            for(int i = 0; i < n; i++)
                // Для считывания студента вызывается
                // соответствующий метод из класса Student
                st[i] = Student.Read(br);

            // Создаем пустую группу
            Group gr = new Group(gn, 0);
            // Записываем в нее студентов
            gr.st = st;

            return gr;
        }
    }

    // Тестирование
    class Test
    {
        static void Main()
        {
            // Группа
            Group gr = new Group("АС-951", 3);

            gr.Input();
            gr.Print();

            // Создаем поток для создания файла и/или записи в него
            FileStream fs = new FileStream("group.bin", 
                FileMode.OpenOrCreate, FileAccess.Write);
            
            // Создаем двоичный поток для записи
            BinaryWriter bw = new BinaryWriter(fs, Encoding.Default);

            // Пишем данные
            gr.Write(bw);
            // Закрываем потоки
            bw.Close();
            fs.Close();

            // Создаем поток для чтения из файла
            fs = new FileStream("group.bin", 
               FileMode.Open, FileAccess.Read);
            // Создаем двоичный поток для чтения
            BinaryReader br = new BinaryReader(fs, Encoding.Default);

            // Читаем данные
            gr = Group.Read(br);
            // Закрываем потоки
            br.Close();
            fs.Close();

            gr.Print();
        }
    }
}


 
 
 

Библиотека программиста. 2009.
Администратор: admin@programmer-lib.ru