Метка: C_Sharp

Урок 1. Введение. Базовые типы данных. Консоль. Классы и методы.
Что такое .NET Framework; Создаем консольное приложение в VisualStudio. Переменные. Типы данных и их преобразование. Выводим и вводим данные через консоль. Первое знакомство с методами и классами.

Урок 2. Управляющие конструкции
Управляем ходом выполнения программы. Используем процедурный подход в написании программ. Познакомимся с рекурсией.

Урок 3. Методы. От структур к объектам. Исключения
Методы; рекурсия; структуры; от структур к объектам; статические поля и методы; исключения;

Урок 4. Массивы. Текстовые файлы
От объектов к массивам. От массивов к “сложным” задачам. Текстовые файлы

Урок 5. Символы, строки, регулярные выражения
Символы и строки; неизменяемые строки; StringBuilder, StringReader и StringWriter; регулярные выражения; практика.

Урок 6. Делегаты, файлы, коллекции
Делегаты; организация системы ввода-вывода; работа с файловой системой; коллекции; практика.

Урок 7. Введение в Windows Forms
От консольного приложения к Windows Forms; события и их обработчики; класс Form; создаём первое приложение.

Урок 8. Программирование “по-взрослому”
О рефлексии; что такое XML; сериализация и десериализация; создаём WindowsForms-приложение “Редактор вопросов для игры “Верю-Не верю”; создаём собственные классы для работы с данными; приложение Windows Forms для работы с XML-файловой базой данных.

Толковое объяснение здесь: https://metanit.com/

Свой пример (см. строки 15, 29-38, 45):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

// Программа нахождения минимума функции на указанном отрезке
// На выбор 2 функции

namespace DoubleBinary
{
    class Program
    {
        delegate double Function(double a, double x);

        private static double F1(double a, double x)
        {
            return a * x * x;
        }

        private static double F2(double a, double x)
        {
            return a * Math.Sin(x);
        }
        
        public static void SaveFunc(string fileName, double a, double b, double h, int func)
        {
            // используя делегат выбираем нужную функцию и дальше ее используем (строка 48)
            Function del;
            if (func == 1)
            {
                del = F1;
            }
            else
            {
                del = F2;
            }

            FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
            BinaryWriter bw = new BinaryWriter(fs);
            double x = a;
            while (x <= b)
            {
                bw.Write(del.Invoke(a, x));
                x += h;
            }
            bw.Close();
            fs.Close();
        }
        public static double Load(string fileName)
        {
            FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            BinaryReader bw = new BinaryReader(fs);
            double min = double.MaxValue;
            double d;
            for (int i = 0; i < fs.Length / sizeof(double); i++)
            {
                // Считываем значение и переходим к следующему
                d = bw.ReadDouble();
                if (d < min) min = d;
            }
            bw.Close();
            fs.Close();
            return min;
        }

        public static int[] Menu()
        {
            int[] variables = new int[3];

            Console.Write("Выберите функцию: 1 - a*x^2; другое число - a*sin(x): ");
            variables[0] = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("На каком отрезке функции находить минимум?\n" +
                "Введите начальное значение X и конечное.\n" +
                "При этом a = начальному значению отрезка: ");
            variables[1] = Convert.ToInt32(Console.ReadLine());
            variables[2] = Convert.ToInt32(Console.ReadLine());

            return variables;
        }

        static void Main(string[] args)
        {
            int[] variables = Menu();

            SaveFunc("data.bin", variables[1], variables[2], 0.5, variables[0]);
            Console.WriteLine(Load("data.bin"));
            
            Console.ReadKey();
        }
    }
}

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

//+ 1. Дан целочисленный массив из 20 элементов.Элементы массива могут принимать целые
//значения от –10 000 до 10 000 включительно.Написать программу, позволяющую найти и
//вывести количество пар элементов массива, в которых хотя бы одно число делится на 3. В
//данной задаче под парой подразумевается два подряд идущих элемента массива.Например,
//для массива из пяти элементов: 6; 2; 9; –3; 6 – ответ: 4.
//+ 2. а) Дописать класс для работы с одномерным массивом.Реализовать конструктор, создающий
//+ массив заданной размерности и заполняющий массив числами от начального значения с
//+ заданным шагом.
//+ Создать свойство Sum, которые возвращают сумму элементов массива, 
//+ метод Inverse, меняющий знаки у всех элементов массива, 
//+ Метод Multi, умножающий каждый элемент массива на определенное число, 
//+ свойство MaxCount, возвращающее количество максимальных элементов.
//+ В Main продемонстрировать работу класса.
//+ б)* Добавить конструктор и методы, которые загружают данные из файла и записывают данные в
// файл

namespace Task_1_2
{
    class Program
    {
        static void Main(string[] args)
        {
            MyArray array1 = new MyArray(20);
            array1.Print();
            Console.WriteLine("Количество пар, делящихся на 3 = " + array1.Pair_to_N(3));

            MyArray array2 = new MyArray(15, 0, 2);
            array2.Print();

            Console.WriteLine("Сумма: " + array2.Sum);

            array2.Inverse();
            Console.Write("Инверсия: ");
            array2.Print();

            array2.Multi(5);
            Console.Write("Умножаем на 5: ");
            array2.Print();

            Console.WriteLine("Количество максимальных элементов в массиве array1: " + array1.MaxCount);
            Console.WriteLine("Количество максимальных элементов в массиве array2: " + array2.MaxCount);
            MyArray array3 = new MyArray(100000);
            Console.WriteLine("Количество максимальных элементов в массиве array3: " + array3.MaxCount);

            MyArray array4 = new MyArray(@"D:\test.txt");
            Console.WriteLine("Тестим чтение из файла");
            array4.Print();
            Console.WriteLine("Тестим запись в файл массива array1 и чтение файла с обновленными данными");
            array1.Rec(@"D:\test.txt");
            Read(@"D:\test.txt");

            Console.ReadKey();
        }

        /// <summary>
        /// Метод считывания из файла txt
        /// </summary>
        /// <param name="filename">имя файла .txt</param>
        static void Read(string filename)
        {
            if (File.Exists(filename))
            {
                //Считываем все строки из файла
                string[] ss = File.ReadAllLines(filename);
                for (int i = 0; i < ss.Length; i++)
                {
                    Console.Write(ss[i] + " ");
                }
                Console.WriteLine();
            }
            else Console.WriteLine("Error load file");
        }
    }

    class MyArray
    {
        int[] a;
        Random rnd = new Random();
        
        /// <summary>
        /// Создаем целочисленный массив со случайными значениями от -10000 до 10000
        /// </summary>
        /// <param name="n">количество элементов</param>
        public MyArray(int n)
        {
            a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = rnd.Next(-10000, 10000);
        }

        /// <summary>
        /// Создаем целочисленный массив, заполняющийся числами от начального значения с заданным шагом.
        /// </summary>
        /// <param name="n">количество элементов</param>
        /// <param name="start">значение 0 элемента массива</param>
        /// <param name="step">шаг изменения каждого последующего значения</param>
        public MyArray(int n, int start, int step)
        {
            a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = start + step * i;
            }
        }

        /// <summary>
        /// Читаем массив из файла
        /// </summary>
        /// <param name="filename">имя файла .txt</param>
        public MyArray(string filename)
        {
            //Если файл существует
            if (File.Exists(filename))
            {
                //Считываем все строки из файла
                string[] ss = File.ReadAllLines(filename);
                a = new int[ss.Length];
                //Переводим данные из строкового формата в числовой
                for (int i = 0; i < ss.Length; i++)
                    a[i] = int.Parse(ss[i]);
            }
            else Console.WriteLine("Error load file");
        }        
        /// <summary>
        /// Свойство для расчета суммы всех элементов целочисленного массива
        /// </summary>
        public int Sum
        {
            get
            {
                int sum = 0;
                for (int i = 0; i < a.Length; i++)
                {
                    sum += a[i];
                }
                return sum;
            }
        }

        /// <summary>
        /// Метод меняющий знаки элементов массива
        /// </summary>
        public void Inverse()
        {
            for (int i = 0; i < a.Length; i++)
            {
                a[i] *= -1;
            }            
        }

        /// <summary>
        /// Метод умножающий все элементы массива на число
        /// </summary>
        /// <param name="x">множитель</param>
        public void Multi(int x)
        {
            for (int i = 0; i < a.Length; i++)
            {
                a[i] *= x;
            }
        }

        /// <summary>
        /// Свойство, показывающие количество элементов массива с максимальным значением
        /// </summary>
        public int MaxCount
        {
            get
            {
                int max = a[0];
                int count = 1;
                for (int i = 1; i < a.Length; i++)
                {
                    if (a[i]>max)
                    {
                        max = a[i];
                        count = 1; 
                    }
                    else if (a[i] == max)
                    {
                        count++;
                    }
                }
                return count;
            }
        }

        /// <summary>
        /// Выводим на консоль все элементы массива в одной строке
        /// </summary>
        public void Print()
        {
            for (int i = 0; i < a.Length; i++)
            {
                Console.Write("{0} ", a[i]);
            }
            Console.WriteLine();
        }

        /// <summary>
        /// Выводит количеств пар элементов массива, делящихся на n без остатка
        /// </summary>
        /// <param name="n">делитель</param>
        /// <returns>количество пар элементов массива</returns>
        public int Pair_to_N(int n)
        {
            int count = 0;
            for (int i = 0; i < (a.Length - 1); i++)
            {
                if ((a[i]%n == 0) || (a[i+1]%n == 0))
                {
                    count++;
                }
            }
            return count;
        }

        /// <summary>
        /// Свойство для записи в файл
        /// </summary>
        /// <param name="filename"></param>
        public void Rec(string filename)
        {
            //переводим данные из чисел в строки
            string[] a_string = new string[a.Length]; 
            for (int i = 0; i < a_string.Length; i++)
                a_string[i] = Convert.ToString(a[i]);

            //пишем массив со строками в файл
            System.IO.File.WriteAllLines(filename, a_string);
        }   
    }
}

 

int x;
string s = Console.ReadLine();

bool flag = int.TryParse(s, out x); //если s нельзя преобразовать в число, то flag = false
x = int.Parse(s); // если s нельзя преобразовать в число, то вылезет исключение