Лабораторная работа по C#

Создание классов
Вариант 1 (класс Point)
Создать класс Point, содержащий следующие члены класса:
– поля: int x, y;
– конструкторы, позволяющие создать экземпляр класса с нулевыми координатами, с заданными координатами;
– методы, позволяющие вывести координаты точки на экран, рассчитать
расстояние от начала координат до точки, переместить точку на плоскости на вектор (a, b);
– свойства, позволяющие получить/установить координаты точки (доступное для чтения и записи), умножить
координаты точки на скаляр
(доступное только для записи);
– индексатор, позволяющий по индексу 0 обращаться к полю x, по индексу 1 –
к полю y, при других значениях индекса выдается сообщение об ошибке;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает)
значение полей х и у на 1; констант true и false – обращение к экземпляру
класса дает значение true, если значение полей x и у совпадает, иначе false;
операции бинарный + – одновременно добавляет к полям х и у значение скаляра.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Lab1
{
public class Point
{
//поля: int x, y;
private int x;
private int y;
//конструктор, позволяющий создать экземпляр класса с нулевыми координатами;
public Point()
{
x = 0;
y = 0;
}
//конструктор, позволяющий создать экземпляр класса с заданными координатами;
public Point(int X,int Y)
{
this.x = X;
this.y = Y;
}
//метод, позволяющий вывести координаты точки на экран;
public override string ToString()
{
return $"x:{this.x} y:{this.y}";
}
//метод, позволяющий рассчитать расстояние от начала координат до точки;
public double GetDistance()
{
double rasst = Math.Sqrt(Math.Pow(this.x, 2) + Math.Pow(this.y, 2));
return rasst;
}

// метод, позволяющий переместить точку на плоскости на вектор (a, b);

public void Move(int a, int b)
{
this.x += a;
 this.y += b;
}

//свойство, позволяющие получить/установить координаты точки (доступное для чтения и записи);

public int X
{
get { return x; }
set { x = value; }
}
public int Y
{
get { return y; }
set { y = value; }
}
//свойство, позволяющие умножить координаты точки на скаляр (доступное только для записи);
public int Scalar
{
set
{
x = this.x * value;
y = this.y * value;
}
}
//индексатор, позволяющий по индексу 0 обращаться к полю x, по индексу 1 – к полю y, при других
значениях индекса выдается сообщение об ошибке;
public int this[int index]
{
get
{
if (index == 0)
return this.x;
else if(index == 1)
return this.y;
else
throw new ArgumentOutOfRangeException(); // иначе генерируем исключение
}
set
{
if(index == 0)
this.x = value;
else if(index == 1)
this.y = value;
}
}
//перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает)
//значение полей х и у на 1;
public static Point operator ++(Point point1)
{
point1.x += 1;
point1.y += 1;
return point1;
}
public static Point operator --(Point point1)
{
point1.x -= 1;
point1.y -= 1;
return point1;
}

//констант true и false – обращение к экземпляру

//класса дает значение true, если значение полей x и у совпадает, иначе false;
public static bool operator true(Point point1)
 {
if(point1.x == point1.y)
return true;
}
public static bool operator false(Point point1)
{
return point1.x == point1.y;
}
//операции бинарный + – одновременно добавляет к полям х и у значение скаляра.
public static Point operator +(Point point1,int scalar)
{
return new Point(point1.x + scalar, point1.y + scalar);
}

}
}

Вариант 2 (класс Triangle)

Создать класс Triangle, содержащий следующие члены класса:
– поля: int a, b, c;
– конструктор, позволяющий создать экземпляр класса с заданными длинами сторон;
– методы, позволяющие вывести длины сторон треугольника на экран, рассчитать периметр треугольника,
рассчитать площадь треугольника;
– свойства, позволяющие получить/установить длины сторон треугольника
(доступное для чтения и записи), установить, существует ли треугольник с данными длинами сторон (доступное
только для чтения);
– индексатор, позволяющий по индексу 0 обращаться к полю a, по индексу 1 –
к полю b, по индексу 2 – к полю c, при других значениях индекса выдается
сообщение об ошибке;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает) значение полей a, b и c на 1; констант
true и false – обращение к экземпляру класса
дает значение true, если треугольник с заданными длинами сторон существует,
иначе – false; операции * – одновременно умножает поля a, b и c на скаляр.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Lab1
{
public class Triangle
{
private int a;
private int b;
private int c;

public Triangle(int A,int B,int C)

{
this.a = A;
this.b = B;
this.c = C;
}

public override string ToString()

{
return $"A:{a} B:{b} C:{c}";
}
public double Perimeter()
{
 return a + b + c;
}
public double Area()
{
double s,p;
p = (a + b + c) / 2;
s = Math.Sqrt(p*(p-a)*(p-b)*(p-c));
return s;
}

public int A { get { return a; } set { a = value; } }

public int B { get { return b; } set { b = value; } }
public int C { get { return c; } set { c = value; } }

public int this[int index]

{
get
{
if (index == 0)
return this.a;
else if (index == 1)
return this.b;
else if (index == 2)
return this.c;
else
throw new ArgumentOutOfRangeException();
}
}
public static Triangle operator ++(Triangle triangle)
{
return new Triangle(triangle.a+1, triangle.b+1, triangle.c+1);
}
public static Triangle operator --(Triangle triangle)
{
return new Triangle(-triangle.a, -triangle.b, -triangle.c);
}
public static Triangle operator *(Triangle triangle,int scalar)
{
return new Triangle(scalar*triangle.a, scalar*triangle.b, scalar*triangle.c);
} }}

Вариант 3(класс Rectangle)

Создать класс Rectangle, содержащий следующие члены класса:
– поля: int a, b;
– конструктор, позволяющий создать экземпляр класса с заданными длинами сторон;
– методы, позволяющие вывести длины сторон прямоугольника на экран,
рассчитать периметр прямоугольника, рассчитать площадь прямоугольника;
– свойства, позволяющие получить/установить длины сторон прямоугольника (доступное для чтения и записи),
установить, является ли данный прямоугольник квадратом (доступное только для чтения);
– индексатор, позволяющий по индексу 0 обращаться к полю a, по индексу 1 –
к полю b, при других значениях индекса выдается сообщение об ошибке;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает) значение полей a и b; констант true и
false – обращение к экземпляру класса дает
значение true, если прямоугольник с заданными длинами сторон является квадратом, иначе – false; операции * –
одновременно умножает поля a и b на скаляр.
public class Rectangle
{
private int a;
private int b;

public Rectangle(int a, int b)

{
this.a = a;
this.b = b;
}

public void GetStr()

{
Console.WriteLine($"A:{a} B:{b}");
}
public int Perimeter()
{
return 2*(a+b);
}
public double Area()
{
return a * b;
}
public int A {
get { return a; }
set { a = value; }
}
public int B
{
get { return b; }
set { b = value; }
}
public bool IsSquare
{
get
{
return a == b;
}
}
public int this[int index]
{
get
{
if(index == 0)
return a;
else if(index == 1)
return b;
else
throw new IndexOutOfRangeException();
}
set
{
if (index == 0)
a = value;
else if (index == 1)
b = value;
else
throw new IndexOutOfRangeException();
}

}
public static Rectangle operator ++(Rectangle r)
{
r.a += 1;
r.b += 1;
return r;
}
public static Rectangle operator --(Rectangle r)
 {
r.a -= 1;
r.b -= 1;
return r;
}
public static bool operator false(Rectangle r)
{
return !r.IsSquare;
}

public static bool operator true(Rectangle r)

{
return r.IsSquare;
}
public static Rectangle operator *(Rectangle r,int scalar)
{
return new Rectangle(scalar*r.a, scalar*r.b);
}
}
Вариант 4(класс Money)
Создать класс Money, содержащий следующие члены класса:
– поля: int first (номинал купюры); int second (количество купюр);
– конструктор, позволяющий создать экземпляр класса с заданными значениям полей;
– методы, позволяющие вывести номинал и количество купюр, определить, хватит ли денежных средств на
покупку товара на сумму N рублей, определить, сколько
штук товара стоимости n рублей можно купить на имеющиеся денежные средства;
– свойства, позволяющие получить/установить значение полей (доступное для чтения и записи), рассчитать
сумму денег (доступное только для чтения);
– индексатор, позволяющий по индексу 0 обращаться к полю first,
по индексу 1 – к полю second, при других значениях индекса выдается
сообщение об ошибке;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает)
значение полей first и second; операции ! – возвращает значение true, если
поле second не нулевое, иначе false; операции бинарный + – добавляет к значению поля second значение скаляра.
public class Money
{
private int first;
private int second;

public Money(int first,int second)

{
this.first = first;
this.second = second;
}
public int First
{
get { return first; }
set { first = value; }
}
public int Second
{
get { return second; }
set { second = value; }
}
public int Summ
{
get
{
return this.second * this.first;
}
 }
public override string ToString()
{
return $"номинал купюры:{first} количество купюр:{second}";
}
public bool EnoughMoney(int N)
{
return this.Summ >= N;
}
public int CountNMoney(int N)
{
return this.Summ / N;
}
public int this[int index]
{
get
{
if (index == 0)
return first;
else if(index==1)
return second;
else
throw new IndexOutOfRangeException();
}
set
{
if (index == 0)
first = value;
else if (index == 1)
second = value;
else
throw new IndexOutOfRangeException();
}
}
public static Money operator ++(Money money)
{
money.first++;
money.second++;
return money;
}
public static Money operator --(Money money)
{
money.first--;
money.second--;
return money;
}
public static bool operator !(Money money)
{
return money.second != 0;
}
public static Money operator +(Money money,int scalar)
{
money.second += scalar;
return money;
}
}
Вариант 5(класс MyIntArray)
Создать класс для работы с одномерным массивом целых чисел. Разработать
следующие члены класса:
– поля: int [] IntArray;
– конструктор, позволяющий создать массив размерности n;
– методы, позволяющие ввести элементы массива с клавиатуры, вывести элементы массива на экран,
отсортировать элементы массива в порядке возрастания;
– свойство, возвращающее размерность массива (доступное только для чтения), и свойство, позволяющее
умножить все элементы массива на скаляр
(доступное только для записи);
– индексатор, позволяющий по индексу обращаться к соответствующему элементу массива;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает)
значение всех элементов массива на 1; операции ! – возвращает значение true,
если элементы массива не упорядочены по возрастанию, иначе – false; операции бинарный * – умножить все
элементы массива на скаляр; операции преобразования класса массив в одномерный массив (и наоборот).
public class MyIntArray
{
private int[] intArray;
public MyIntArray(int n)
{
intArray = new int[n];
}
public void SetArray()
{
this.intArray = new int[this.intArray.Length];
for (int i = 0; i < this.intArray.Length; i++)
{
int n = Int32.Parse(Console.ReadLine());
this.intArray[i] = n;
}
}
public void GetArray()
{
for (int i = 0; i < this.intArray.Length; i++)
Console.Write($"{this.intArray[i]} ");
Console.WriteLine();
}
public void SortArray()
{
for (int i = 0; i < this.intArray.Length; i++)
{
for (int j = 0; j < this.intArray.Length - 1; j++)
{
if (this.intArray[j] > this.intArray[j + 1])
{
int z = this.intArray[j];
this.intArray[j] = this.intArray[j + 1];
this.intArray[j + 1] = z;
}
}
}
}
public int GetCountArr
{
get
{
return this.intArray.Length;
}
}
public int Multiply
{
set
{
if (value > 0)
{
int[] tempA = new int[this.intArray.Length];
 for(int i =0; i < this.intArray.Length; i++)
tempA[i] = value*this.intArray[i];
this.intArray = tempA;
}
}
}
public int this[int index]
{
get { return this.intArray[index]; }
set { this.intArray[index] = value; }
}
public static MyIntArray operator ++(MyIntArray myInt)
{
for(int i = 0; i < myInt.intArray.Length; i++)
myInt[i]++;
return myInt;
}
public static MyIntArray operator --(MyIntArray myInt)
{
for(int j = 0; j < myInt.intArray.Length; j++)
myInt[j]--;
return myInt;
}
public static bool operator !(MyIntArray myInt)
{
for(int i = 0; i<myInt.intArray.Length; i++)
if (myInt[i] > myInt[i + 1])
return true;
return false;
}
public static MyIntArray operator *(MyIntArray myInt,int scalar)
{
for(int i = 0; i< myInt.intArray.Length; i++)
myInt[i] *= scalar;
return myInt;
}
public static explicit operator MyIntArray(int[] array)
{
MyIntArray transformation = new MyIntArray(array.Length);
array.CopyTo(transformation.intArray, 0);
return transformation;
}

public static explicit operator int[](MyIntArray transformation)

{
return transformation.intArray;
}
}
Вариант 6(класс TwoArray)
Создать класс для работы с двумерным массивом целых чисел. Разработать
следующие члены класса:
– поля: int [,] intArray;
– конструктор, позволяющий создать массив размерности n×m;
– методы, позволяющие ввести элементы массива с клавиатуры, вывести
элементы массива на экран, вычислить сумму элементов i-го столбца;
– свойства, позволяющие вычислить количество нулевых элементов в массиве (доступное только для чтения),
установить значение всех элементов главной
диагонали массива, равное скаляру (доступное только для записи);
– двумерный индексатор, позволяющий обращаться к соответствующему элементу массива;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает)
значение всех элементов массива на 1; констант true и false – обращение к экземпляру класса дает значение true,
если двумерный массив является квадратным; операции бинарный + – сложить два массива соответствующих
размерностей; операции преобразования класса массив в двумерный массив (и наоборот).
public class TwoArray
{
private int[,] intArray;
private int rows;
private int columns;

public TwoArray(int n,int m)

{
intArray = new int[n, m];
rows = n;
columns = m;
}
public void InputArray()
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
Console.WriteLine($"Введите значение для элемента {i} {j}: \t");
intArray[i,j] = Int32.Parse(Console.ReadLine());
}
}
}
public void PrintArray()
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
Console.Write($"{intArray[i,j]} \t");
}
Console.WriteLine();
}
}
public int SummColumn(int col)
{
int sum = 0;
for (int i = 0; i < rows; i++)
{
sum += intArray[i,col];
}
return sum;
}
public int CountNullElem
{
get
{
int k = 0;
for (int i = 0; i < rows; i++)
for (int j = 0; j < columns; j++)
if (intArray[i, j] == 0)
k++;
return k;
}
}
public int DiagElemInput
{
set
{
for (int i = 0; i < Math.Min(rows, columns); i++)
 intArray[i, i] = value;
}
}
public double this[int N, int M]
{
get
{
if (N >= rows || M >= columns)
throw new ArgumentOutOfRangeException();

return intArray[N,M];
}
set
{
if (N >= rows || M >= columns)
throw new ArgumentOutOfRangeException();

intArray[N,M] = (int)value;
}
}
public static TwoArray operator ++(TwoArray twoArray)
{
for (int i = 0; i < twoArray.rows; i++)
for(int j = 0; j < twoArray.columns; j++)
twoArray[i,j]++;
return twoArray;
}
public static TwoArray operator --(TwoArray twoArray)
{
for (int i = 0; i < twoArray.rows; i++)
for (int j = 0; j < twoArray.columns; j++)
twoArray--;
return twoArray;
}
public static bool operator true(TwoArray twoArray)
{
return twoArray.rows == twoArray.columns;
}
public static bool operator false(TwoArray twoArray)
{
return twoArray.rows != twoArray.columns;
}
public static TwoArray operator +(TwoArray twoArray1,TwoArray twoArray2)
{
TwoArray result = new TwoArray(twoArray1.rows, twoArray1.columns);
for (int i = 0; i < twoArray1.rows; i++)
for (var j = 0; j < twoArray1.columns; j++)
result[i,j] = (int)twoArray1[i,j]+(int)twoArray2[i,j];
return result;
}
public static explicit operator TwoArray(int[,] array)
{
TwoArray transformation = new TwoArray((int)array.GetLength(0), (int)array.GetLength(1));
array.CopyTo(transformation.intArray, 0);
return transformation;
}

public static explicit operator int[,](TwoArray transformation)

{
return transformation.intArray;
}
}
Вариант 7(класс DoubelArray)
Создать класс для работы с двумерным массивом вещественных чисел. Разработать следующие функциональные
члены класса:
– поля: double [][] doubelArray;
– конструктор, позволяющий создать ступенчатый массив;
– методы, позволяющие ввести элементы массива с клавиатуры, вывести
элементы массива на экран, отсортировать элементы каждой строки массива в порядке убывания;
– свойство, возвращающее общее количество элементов в массиве (доступное только для чтения), и свойство,
позволяющее увеличить значение всех элементов массива на скаляр (доступное только для записи);
– двумерный индексатор, позволяющий обращаться к соответствующему элементу массива;
– перегрузку: операции ++ (‐‐) – одновременно увеличивает (уменьшает)
значение всех элементов массива на 1; констант true и false – обращение к экземпляру класса дает значение true,
если каждая строка массива упорядочена по
возрастанию, иначе – false; операции преобразования класса массив в ступенчатый массив (и наоборот).
class ArrayDouble
{
// Поля: •double [][] DoubleArray; •int n, m.
int n, m;
double[,] DoubleArray;

// Конструктор, позволяющий создать массив размерности n×m.

public ArrayDouble(int n, int m)
{
this.n = n;
this.m = m;

DoubleArray = new double[n,m];

}

public ArrayDouble() { }

// Ввести элементы массива с клавиатуры;

public void Enter_Array()
{
for(int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
{
Console.Write("Введите элемент DoubleArray[{0},{1}] = ", i, j);
DoubleArray[i, j] = double.Parse(Console.ReadLine());
}
}

// Вывести элементы массива на экран

public void Display_Array()
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
Console.Write(" " + DoubleArray[i, j] + " ");
}
Console.WriteLine();
}
}

// Отсортировать элементы каждой строки массива в порядке убывания.

public void Sort()
{
bool a;
double temp;
for (int i = 0; i < n; i++)
 {
a = true;
while (a)
{
a = false;
for (int j = 0; j < m - 1; j++)
{
if (DoubleArray[i, j] < DoubleArray[i, j + 1])
{
temp = DoubleArray[i, j];
DoubleArray[i, j] = DoubleArray[i, j + 1];
DoubleArray[i, j + 1] = temp;
a = true;
}
}
}
}
}

// Возвращающее общее количество элементов в массиве (доступное только для чтения);

public int Total_Elements
{
get
{
return n * m;
}
}

// Позволяющее увеличить значение всех элементов массива на скаляр (доступное только для
записи).
public double Array_Scal
{
set
{
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
DoubleArray[i, j] *= value;
}
}

//Двумерный индексатор, позволяющий обращаться к соответствующему элементу массива.

public double this[int i, int j]
{
get { return DoubleArray[i, j]; }
}

// Операция ++: одновременно увеличивает значение всех элементов массива на 1;

public static ArrayDouble operator ++(ArrayDouble obj)
{
for (int i = 0; i < obj.n; i++)
for (int j = 0; j < obj.m; j++)
obj.DoubleArray[i, j] = obj.DoubleArray[i, j] + 1;
return obj;
}

// Операция --: одновременно уменьшает значение всех элементов массива на 1;

public static ArrayDouble operator --(ArrayDouble obj)
{
for (int i = 0; i < obj.n; i++)
for (int j = 0; j < obj.m; j++)
obj.DoubleArray[i, j] = obj.DoubleArray[i, j] - 1;
return obj;
 }

// константа true: обращение к экземпляру класса дает значение true, если каждая строка массива
упорядоченна по возрастанию, иначе false.
public static bool operator true(ArrayDouble obj)
{
int count = 0;
for(int i = 0; i < obj.n; i++)
for(int j = 0; j < obj.m - 1; j++)
if(obj.DoubleArray[i,j] > obj.DoubleArray[i, j+1])
count++;
if (count == 0)
return true;
return false;
}

// Константа false: обращение к экземпляру класса дает значение true, если каждая строка массива
упорядоченна по возрастанию, иначе false.
public static bool operator false(ArrayDouble obj)
{
int count = 0;
for (int i = 0; i < obj.n; i++)
for (int j = 0; j < obj.m - 1; j++)
if (obj.DoubleArray[i, j] > obj.DoubleArray[i, j + 1])
count++;
if (count != 0)
return false;
return true;
}

// Преобразования класса массив в ступенчатый массив (и наоборот)

public static explicit operator double[][](ArrayDouble obj)
{
double[][] array = new double[obj.n][];
for (int i = 0; i < obj.n; i++)
{
array[i] = new double[obj.m];
for (int j = 0; j < obj.m; j++)
array[i][j] = obj.DoubleArray[i, j];
}
return array;
}

public static explicit operator ArrayDouble(double[][] array)

{
int n, m;
n = array.Length;
m = array[0].Length;
ArrayDouble obj = new ArrayDouble(n, m);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
obj.DoubleArray[i, j] = array[i][j];
}
return obj;
}
}
class Program
{
static void Main(string[] args)
{
int n, m;
 Console.WriteLine("Введите колчество столбцов: ");
n = int.Parse(Console.ReadLine());
Console.WriteLine("Введите колчество строк: ");
m = int.Parse(Console.ReadLine());
ArrayDouble array = new ArrayDouble(n, m);

Console.WriteLine("Ввод массива:");
array.Enter_Array();

Console.WriteLine("\nПоказать массив:");
array.Display_Array();

Console.WriteLine("\nОтсортировать массив в порядке убывания:");

array.Sort();
Console.WriteLine("Показать отсортированный массив:");
array.Display_Array();

Console.WriteLine("Операция ++: одновременно увеличивает значение всех элементов массива на

1:");
array++;
array.Display_Array();

Console.WriteLine("Операция --: одновременно уменьшает значение всех элементов массива на

1");
array--;
array.Display_Array();

Console.WriteLine("\nКонстанты true и false:" +

"обращение к экземпляру класса дает значение true, если каждая строка массива упорядоченна
по возрастанию, иначе false.\n");
if (array) Console.WriteLine("Строки массива упорядочены по возростаню.");
else
Console.WriteLine("Строки массива не упорядочены по возростанию.");

Console.ReadLine();
}
}

Вариант 8
Создать класс для работы со строками. Разработать следующие члены класса:
– поле: string line;
– конструктор, позволяющий создать строку на основе заданного
строкового литерала;
– методы, позволяющие подсчитать количество цифр в строке, выводить на
экран все символы строки, встречающиеся в ней ровно один раз, вывести на
экран самую длинную последовательность повторяющихся символов в строке;
– свойство, возвращающее общее количество символов в строке (доступное
только для чтения);
– индексатор, позволяющий по индексу обращаться к соответствующему
символу строки (доступный только для чтения);
– перегрузку: операции унарного ! – возвращает значение true, если строка
не пустая, иначе – false; констант true и false – обращение к экземпляру
класса дает значение true, если строка является палиндромом, false – в противном случае; операции & –
возвращает значение true, если строковые поля
двух объектов посимвольно равны (без учета регистра), иначе – false; операции
преобразования класса строка в тип string (и наоборот).
1-

Вариант 9(класс StringBuilder)

Создать класс для работы сo строками. Разработать следующие члены класса:
– поле: StringBuilder line;
– конструктор, позволяющий создать строку на основе заданного строкового литерала, и конструктор,
позволяющий создавать пустую строку;
– методы, позволяющие подсчитать количество пробелов в строке,заменить в строке все прописные символы на
строчные, удалить из строки все знаки препинания;
– свойство, возвращающее общее количество элементов в строке (доступное только для чтения), и свойство,
позволяющее установить значение поля в
соответствии с введенным значением строки с клавиатуры, а также получить значение данного поля (доступно
для чтения и записи);
– индексатор, позволяющий по индексу обращаться к соответствующему символу строки;
– перегрузку: операции унарного + (‐) – преобразующей строку к строчным (прописным) символам; констант true
и false – обращение к экземпляру
класса дает значение true, если строка не пустая, иначе – false; операции & –
возвращает значение true, если строковые поля двух объектов посимвольно
равны (без учета регистра), иначе – false; операции преобразования строки в
тип StringBuilder (и наоборот).
class MyString
{
// Поля: •StringBuilder Line;• int n.
int n;
StringBuilder Line;

// Конструктор, позволяющий создать строку из n символов.

public MyString(string str)
{
Line = new StringBuilder(str);
n = str.Length;
}

// Подсчитать количество пробелов в строке

public int Space_Count()
{
int count = 0;
for (int i = 0; i < Line.Length; i++)
if (char.IsWhiteSpace(Line[i])) count++;
return count;
}

// Заменить в строке все прописные символы на строчные;

public string Line_ToLower()
{
return Line.ToString().ToLower();
}

// Удалить из строки все знаки препинания.

public string Punctuation()
{
return Line.ToString().Replace(",", "").Replace("!", "").Replace(".", "").Replace(";", "").Replace(":", "");
}

//Свойства: возвращающее общее количество элементов в строке (доступное только для чтения);
public int N
{
get { return Line.Length; }
}

//Свойства: позволяющее установить значение поля, в соответствии с введенным значением строки с

клавиатуры,
//а также получить значение данного поля (доступно для чтения и записи)
 public int Set_N
{
get { return n; }
set { n = value; }
}

//Индексатор, позволяющий по индексу обращаться к соответствующему символу строки.

public char this[int index]
{
get { return Line[index]; }
}

//Преобразования класса-строка в тип string (и наоборот).

public static explicit operator string(MyString obj)
{
return obj.Line.ToString();
}

public static explicit operator MyString(string obj)

{
return new MyString(obj);
}

//Операции унарного +: преобразующей строку к строчным символам;

public static string operator +(MyString obj)
{
return obj.Line.ToString().ToLower();
}

//Операция унарного -: преобразующей строку к прописным символам;

public static string operator -(MyString obj)
{
return obj.Line.ToString().ToUpper();
}

//Констант true и false: обращение к экземпляру класса дает значение true, если строка не пустая,
иначе false.
public static bool operator true(MyString obj)
{
if (obj.Line.Length != 0)
return true;
return false;
}
public static bool operator false(MyString obj)
{
if (obj.Line.Length == 0)
return true;
return false;
}

//операции &: возвращает значение true, если строковые поля двух объектов посимвольно равны (без
учета регистра), иначе false;
public static bool operator &(MyString obj1, MyString obj2)
{
return obj1.Line.ToString().ToUpper().Equals(obj2.Line.ToString().ToUpper());
}

}
class Program
{
static void Main(string[] args)
{
 Console.WriteLine("Введите строку:");
string str = Console.ReadLine();
MyString Line = new MyString(str);

Console.WriteLine("Количество пробелов в строке - {0}", Line.Space_Count());

Console.WriteLine("Заменить в строке все прописные символы на строчные: \n{0}",

Line.Line_ToLower());

Console.WriteLine("Удалить из строки все знаки препинания: \n{0}", Line.Punctuation());

Console.WriteLine("Количество символов в строке: {0}", Line.N);

Console.WriteLine(@"Перегрузка операции &: возвращает значение true, если строковые поля двух
объектов посимвольно равны (без учета регистра), иначе false:");
Console.WriteLine("Введите строку:");
str = Console.ReadLine();
MyString Line2 = new MyString(str);
Console.WriteLine("Равны ли строки? {0}", Line & Line2);

Console.WriteLine("Преобразование строки к строчным символам : \n {0}", -Line);

Console.WriteLine("Преобразование строки к прописным символам: \n {0}", +Line);

if (Line)
Console.WriteLine("Строка не пустая.");
else
Console.WriteLine("Строка пустая.");

Console.ReadLine();
}
}
}

Вариант 10(класс Date)

Самостоятельно изучите тип данных DateTime, на основе которого необходимо создать класс для работы с датой.
Данный класс должен содержать следующие члены класса:
– поле DataTime data;
– конструкторы, позволяющие установить заданную дату, дату 1.01.2000;
– методы, позволяющие вычислить дату предыдущего дня, вычислить дату следующего дня, определить сколько
дней осталось до конца месяца;
– свойства, позволяющие установить или получить значение поле класса (доступно для чтения и записи),
определить, является ли год високосным (доступно только для чтения);
– индексатор, позволяющий определить дату i-го по счету дня относительно установленной даты (при
отрицательных значениях индекса отсчет ведется в обратном порядке);
– перегрузку: операции ! – возвращает значение true, если установленная дата не является последним днем
месяца, иначе – false;
– констант true и false – обращение к экземпляру класса дает значение true, если установленная дата является
началом года, иначе – false;
– операции & – возвращает значение true, если поля двух объектов равны, иначе false.
class DateClass
C#
class DateClass
{
// Поле DataTime data.
DateTime date;

// Конструкторы, позволяющие установить: • заданную дату

public DateClass(int year, int month, int day)
{
 date = new DateTime(year, month, day);
}

// дату 1.01.2009
public DateClass()
{
date = new DateTime(2009, 1, 1);
}

// Методы, позволяющие: • вычислить дату предыдущего дня;

public DateTime PrevDay()
{
return date.AddDays(-1);
}

// • вычислить дату следующего дня;

public DateTime NextDay()
{
return date.Add(TimeSpan.FromDays(1));
}

// определить сколько дней осталось до конца месяца.

public int DaysLeft()
{
return DateTime.DaysInMonth(date.Year, date.Month) - date.Day;
}

//Свойства:• позволяющее установить или получить значение поле класса (доступно для чтения
и записи)
public DateTime Data
{
set { date = value; }
get { return date; }
}

//позволяющее определить год высокосным (доступно только для чтения)

public bool IsLeap
{
get { return DateTime.IsLeapYear(date.Year); }
}

// Индексатор, позволяющий определить дату i-того по счету дня относительно установленной даты
// (при отрицательных значениях индекса отсчет ведется в обратном порядке).
public DateTime this[int index]
{
get
{
return date.AddDays(index);
}
}

//Перегрузку: • операции !: возвращает значение true, если установленная дата не является

последним днем месяца, иначе false;

public static bool operator !(DateClass a)

{
return a.date.Day != DateTime.DaysInMonth(a.date.Year, a.date.Month);
}

// констант true и false: обращение к экземпляру класса дает значение true,

// если установленная дата является началом года, иначе false;
public static bool operator true(DateClass a)
 {
return a.date.Day == 1 && a.date.Month == 1;
}

public static bool operator false(DateClass a)

{
return a.date.Day != 1 || a.date.Month != 1;
}

// операции &: возвращает значение true, если поля двух объектов равны, иначе false;
public static bool operator &(DateClass a, DateClass b)
{
return a.date.Equals(b.date);
}

public static explicit operator String(DateClass obj)

{
return " Год: " + obj.date.Year + " Месяц: " + obj.date.Month + " Число: " + obj.date.Day;
}

public static explicit operator DateClass(String str)

{
string[] str_arr = str.Split(new char[] {' ', ','}, StringSplitOptions.RemoveEmptyEntries);
DateClass obj = new DateClass(Convert.ToInt32(str_arr[0]), Convert.ToInt32(str_arr[1]),
Convert.ToInt32(str_arr[2]));
return obj;
}

class Program
{
static void Main(string[] args)
{
DateClass my = new DateClass();

Console.WriteLine("Текущая дата: {0}", (string)my);

my = new DateClass(2013, 12, 7);

Console.WriteLine("Изменить дату на 7.12.2013: {0}", (string)my);

Console.WriteLine("Дата предыдущего дня: {0}", my.PrevDay());

Console.WriteLine("Дата следующего дня: {0}", my.NextDay());

Console.WriteLine("Количество дней до конца месяца: {0}", my.DaysLeft());

Console.WriteLine(@"Индексатор, позволяющий определить дату i-того по счету дня относительно

установленной даты.
Добавить к дате 10 дней: {0}", my[10]);

Console.WriteLine("Является ли год выскокосным? {0}", my.IsLeap);

Console.WriteLine("Перегрузка операции !: true, если дата не является последним днем месяца,

иначе false: {0}", !my);

Console.WriteLine("Создается новый обьект DaateClass(2013, 12, 18)");

DateClass my1 = new DateClass(2013, 12, 18);

 Console.WriteLine("Перегрузка операции &: true, если поля двух объектов равны, иначе false: {0}",
my1 & my);

Console.WriteLine("Преобразования класса DataTime в тип string: {0}", (string)my);

string str = "2014, 12, 01";

my = (DateClass)str;

Console.WriteLine("Преобразования класса string в тип DataTime (2014, 12, 01): {0}", (string)my);

Console.ReadKey();
}
}