kaloyankibarev07b 1.0.0
dotnet add package kaloyankibarev07b --version 1.0.0
NuGet\Install-Package kaloyankibarev07b -Version 1.0.0
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="kaloyankibarev07b" Version="1.0.0" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
<PackageVersion Include="kaloyankibarev07b" Version="1.0.0" />
<PackageReference Include="kaloyankibarev07b" />
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.
paket add kaloyankibarev07b --version 1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: kaloyankibarev07b, 1.0.0"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
#:package kaloyankibarev07b@1.0.0
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.
#addin nuget:?package=kaloyankibarev07b&version=1.0.0
#tool nuget:?package=kaloyankibarev07b&version=1.0.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
// Age = age;
// }
//
// public string Name
// {
// get { return Name; }
// private set { name = value; }
// }
// public int age
// {
// get { return age; }
// private set { age = value; }
// }
// }
// ПРАВИЛЕН КОД
// public class Dog
// {
// private string name;
// private int age;
//
// public Dog(string name, int age)//2t
// {
// Name = name;
// Age = age;
// }
//
// public string Name
// {
// get { return name; }//2t
// private set { name = value; }
// }
// public int Age //2t
// {
// get { return age; }
// private set { age = value; }
// }
//
// }
//
// Дайте пример за клас в C#. Нека този клас моделира реалния обект училище(School) и притежава полетата (fields) и свойствата (properties): име (name), адрес (address), информация (information).
//
// public class School
// {
// private string name;
// private string address;
// private string information;
// public string Name
// {
// get { return name; }
// set { name = value; }
// }
// public string Address
// {
// get { return address; }
// set { address = value; }
// }
// public string Information
// {
// get { return information; }
// set { information = value; }
// }
//
// }
//
//
//
//
// Дефиниране на клас BankAccount (банкова сметка)
// Създайте клас BankAccount.
//
// Този клас трябва да има полета за:
//
// · id: int
//
// · balance: decimal
//
// Класът трябва да има свойства за:
//
// · ID: int
//
// · Balance: decimal
//
// Конструктор:
//
// · BankAccount(int id, decimal balance)
//
// Създайте методите:
//
// · Deposit(decimal amount): void – който да вкарва пари в сметката. Ако количество пари, което се подава като параметър на метода е отрицателно число, на конзолата да се изведе съобщение: „Amount must be positive number!“
//
// · Withdraw(decimal amount): void – който да изтегля пари от сметката. Ако количеството пари, което се подава като параметър на метода е повече от наличния баланс, на конзолата да изведе съобщение: „Insufficient Balance!“
//
// Заменете метода ToString()!
//
// using System;
//
// class Program
// {
// static void Main(string[] args)
// {
// BankAccount account = new BankAccount(1, 20);
//
// account.Deposit(100);
// Console.WriteLine(account);
//
// account.Withdraw(200);
// Console.WriteLine(account);
// }
// }
//
//
//
//
//
//
//
// using System;
//
// public class BankAccount
// {
// private int id;
// private decimal balance;
//
// public BankAccount(int id, decimal balance)
// {
// this.Id = id;
// this.Balance = balance;
// }
//
// public int Id
// {
// get { return id; }
// private set { id = value; }
// }
//
// public decimal Balance
// {
// get { return balance; }
// private set { balance = value; }
// }
//
// public void Deposit(decimal amount)
// {
// if (amount < 0)
// {
// Console.WriteLine("Amount must be positive number!");
// return;
// }
//
// this.Balance += amount;
// }
//
// public void Withdraw(decimal amount)
// {
// if (amount > this.Balance)
// {
// Console.WriteLine("Insufficient Balance!");
// return;
// }
//
// this.Balance -= amount;
// }
//
// public override string ToString()
// {
// return $"Account {this.Id}, balance {this.Balance}";
// }
// }
//
//
//
//
//
// Петя е начинаещ програмист и е написала прост клас на C#, но е забравила да спази един много важен принцип в обектно-ориентираното програмиране - а именно спазването на правилната енкапсулация на данните! За да докажете, че различавате модификаторите за достъп до елементите в даден клас, попълнете правилните модификатори в дадения код!
//
//
// [public] class Turtle
// {
// [private] string name;
// [private] int age;
// [public] Turtle(string name, int age)
// {
// Name = name;
// Age = age;
// }
// [public] string Name
// {
// get { return name; }
// [private] set { name = value; }
// }
// [public] int Age
// {
// get { return age; }
// [private] set { age = value; }
// }
//
// [public] void MakeTrick()
// {
// Console.WriteLine("I do a triple somersault!");
// }
// }
//
//
// Обяснете какво правят т.нар getters в C#:
// метод за четене на стойността на едно свойство
//
//
//
// Дайте пример за клас в C#. Нека този клас моделира реалния обект книга и притежава полетата и свойствата: име, автор, брой страници.
// public class Book
// {
// private string name;
// public string Name
// {
// get { return name; }
// set { name = value; }
// }
//
// private string author;
//
// public string Author
// {
// get { return author; }
// set { author = value; }
// }
//
// private int pages;
//
// public int Pages
// {
// get { return pages; }
// set { pages = value; }
// }
// }
//
//
//
//
// Дадени са следните фрагменти от код на C#. От вас се очаква да различавате кое от посочените е конструктор, кое е метод, кое е свойство и кое поле. Срещу всяка снимка има поле, от което трябва да изберете вярното:
// ПОЛЕ
// КОНСТРУКТОР
// СВОЙСТВО
// МЕТОД
//
//
//
//
// Открийте грешката в кода и я поправете, така че програмата да работи правилно:
// ГРЕШЕН КОД
// public class Dog
// {
// private int count;
// public Dog()
// {
// count++;
// }
//
// public int Count { get => count; }
// }
//
// public class Program
// {
// static void Main(string[] args)
// {
// Dog dog = new Dog();
// Console.WriteLine(dog.Count);
// }
// }
//
// ПРАВИЛЕН КОД
// public class Dog
// {
// private static int count;//2т
// public Dog()
// {
// count++;
// }
//
// public static int Count { get => count; }//2т
// }
//
// public class Program
// {
// static void Main(string[] args)
// {
// Dog dog = new Dog();
// Console.WriteLine(Dog.Count);//2т
// }
// }
//
// Дефинирайте за кого ще е видимо поле/метод в C#, ако то е с модификатор за достъп public?
//
// може да бъде достъпен от всеки друг клас, независимо дали е от текущия проект, от текущото пространство от имена или извън тях.
//
//
// Дайте примерен код на C# за метод само за четене на стойността на едно свойство. (Например свойството Age). Спазвайте правилната енкапсулация на данните!
//
// public int Age
// {
// get { return age; }
// }
//
//
//
//
//
//
//
// ТЕСТ 4
//
//
//
// Посочете кое от изброените твърдение е вярно за класовете в C#.
//
// Можем да създаваме инстанции., Описва състоянието и поведението на обектите
//
//
//
// Свържете кои от характеристиките се отнасят за абстракцията, кои за енкапсулацията.
// Енкапсулация
// Абстракция
// Абстракция
// Енкапсулация
//
//
//
//
//
// Създайте следната йерархия от класове и интерфейси.
//
// За ваше удобство ще ви бъде предоставен скелет на задачата, който обаче е непълен/неработещ/некоректен. Предоставеният скелет трябва да се приведе в работещ вид.
//
// Интерфейс IMakeNoise
// · Този интерфейс трябва да съдържа сигнатурата на метод string MakeNoise()
//
// Интерфейс IMakeTrick
// · Този интерфейс трябва да съдържа сигнатурата на метод string MakeTrick()
//
// Интерфейс IAnimal
//
//
//
//
// using System;
// using System.Collections.Generic;
// using System.Linq;
//
// // INTERFACES
// interface IMakeNoise
// {
// string MakeNoise();
// }
//
// interface IMakeTrick
// {
// string MakeTrick();
// }
//
// interface IAnimal : IMakeNoise, IMakeTrick
// {
// string Type { get; }
// string Name { get; }
// void Perform();
// }
//
// // ABSTRACT CLASS
// abstract class Animal : IAnimal
// {
// private string name;
//
// protected Animal(string name)
// {
// this.Name = name;
// }
//
// public string Name
// {
// get { return name; }
// private set
// {
// if (string.IsNullOrWhiteSpace(value))
// {
// throw new ArgumentException("Name can't be null or empty!");
// }
// name = value;
// }
// }
//
// public abstract string Type { get; }
//
// public abstract string MakeNoise();
// public abstract string MakeTrick();
//
// public void Perform()
// {
// Console.WriteLine($">>> {this.MakeNoise()}");
// Console.WriteLine($">>> {this.MakeTrick()}");
// }
//
// public override string ToString()
// {
// return $"{this.Type} {this.Name}";
// }
// }
//
// // CAT
// class Cat : Animal
// {
// public Cat(string name) : base(name) { }
//
// public override string Type => "Cat";
//
// public override string MakeNoise()
// {
// return "Meow!";
// }
//
// public override string MakeTrick()
// {
// return "No trick for you! I'm too lazy!";
// }
// }
//
// // DOG
// class Dog : Animal
// {
// public Dog(string name) : base(name) { }
//
// public override string Type => "Dog";
//
// public override string MakeNoise()
// {
// return "Woof!";
// }
//
// public override string MakeTrick()
// {
// return "Hold my paw, human!";
// }
// }
//
// // TRAINER
// class Trainer
// {
// private IAnimal entity;
// private string name;
//
// public Trainer(string name, IAnimal entity)
// {
// this.Name = name;
// this.Entity = entity;
// }
//
// public string Name
// {
// get { return name; }
// private set
// {
// if (string.IsNullOrWhiteSpace(value))
// {
// throw new ArgumentException("Name can't be null or empty!");
// }
// name = value;
// }
// }
//
// public IAnimal Entity
// {
// get { return entity; }
// private set { entity = value; }
// }
//
// public void Work(IAnimal entity)
// {
// this.Entity = entity;
// Console.WriteLine($"Trainer {this.Name} works with {Entity}!");
// }
//
// public void Make()
// {
// this.Entity.Perform();
// }
// }
//
// // PROGRAM
// class Program
// {
// static void Main(string[] args)
// {
// List<IAnimal> animals = new List<IAnimal>();
//
// int n = int.Parse(Console.ReadLine());
//
// for (int i = 0; i < n; i++)
// {
// string[] line = Console.ReadLine().Split();
// IAnimal animal = CreateAnimal(line);
// animals.Add(animal);
// }
//
// string trainerName = Console.ReadLine();
// Trainer trainer = null;
//
// string name = Console.ReadLine();
//
// while (name != "End")
// {
// IAnimal current = animals.FirstOrDefault(a => a.Name == name);
//
// if (current == null)
// {
// Console.WriteLine("No such name in the Database!");
// }
// else
// {
// if (trainer == null)
// {
// trainer = new Trainer(trainerName, current);
// }
//
// trainer.Work(current);
// trainer.Make();
// }
//
// name = Console.ReadLine();
// }
// }
//
// private static IAnimal CreateAnimal(string[] line)
// {
// switch (line[0])
// {
// case "Cat": return new Cat(line[1]);
// case "Dog": return new Dog(line[1]);
// default: return null;
// }
// }
// }
//
//
//
//
//
//
// Свържете кои от характеристиките се отнасят за абстрактните класове, кои за интерфейсите.
// Абстракция
// Абстракция
// И за двете
// Абстракция
// Интерфейси
// Интерфейси
//
//
//
//
// Дайте пример чрез код на C# за това как и къде бихте използвали презаписване на методи.
//
// Например имате класовете Animal и Dog. Имате и един единствен метод MakeTrick(), който трябва да отпечатва на конзолата за всички животни, че по подразбиране не могат да правят никакъв трик ("No trick!"). Само и единствено кучето умее трика да подава лапа ("Give a paw!").
//
// Реализирайте примера чрез код на C#.
//
// class Animal
// {
// public virtual void MakeTrick()
// {
// Console.WriteLine("No trick...");
// }
// }
// class Dog : Animal
// {
// public override void MakeTrick()
// {
// Console.WriteLine("Give a paw...");
// }
// }
//
//
//
//
// Дайте пример за абстракция. Напишете примерен код, който:
//
// Има класовете BaseEmployee, FullTimeEmployee и ContractEmployee.
//
// Условието на задачата е всички работници да имат име, както и метод CalculateSalary(int workingHours) - който ще изчислява заплатата за работника, като се приема параметър – брой изработени часове.
//
// Заплатата на FullTimeEmployee се изчислява по формулата: 250 + workingHours*10.80.
//
// А заплатата на ContractEmployee по формулата: 250 + workingHours*20.
//
// Спазвайте принципа за абстракция в обектно-ориентираното програмиране.
//
// abstract class BaseEmployee
// {
// public string Name { get; set; }
// public abstract double CalculateSalary(int workingHours);
// }
//
// class FullTimeEmployee : BaseEmployee
// {
// public override double CalculateSalary(int workingHours)
// {
// return 250 + workingHours * 10.80;
// }
// }
//
// class ContractEmployee : BaseEmployee
// {
// public override double CalculateSalary(int workingHours)
// {
// return 250 + workingHours * 20;
// }
// }
//
//
//
//
//
// Посочете по какъв начин бихте декларирали шаблонен клас (с примерно име MyClass) в C#.
// class MyClass<T>
// {
//
// }
//
//
//
//
//
//
// Имате следния код:
//
// public List<int> CreateList(int item, int count)
// {
// List<int> list = new List<int>();
// for (int i = 0; i < count; i++)
// {
// list.Add(item);
// }
// }
//
// Модифицирайте кода,така че методът да работи с всякакъв тип данни.
//
// public List<T> CreateList<T>(T item, int count)//2т
// {
// List<T> list = new List<T>();//2т
// for (int i = 0; i < count; i++)
// {
// list.Add(item);
// }
// return list;//2т
// }
//
//
// Посочете видовете полиморфизъм в .NET.
// Полиморфизъм по време на компилиране., Полиморфизъм по време на изпълнение.
//
//
//
//
// Открийте разликите между клас и интерфейс. Кои от изброените твърдения се отнасят за класовете в C#, кои за интерфейсите?
//
// Има както дефиниция, така и реализация. [Клас]
//
// Има само дефиниция. [Интерфейс]
//
// Не може да бъде инстанциран. [Интерфейс]
//
// Може да бъде инстанциран. [Клас]
//
// Може да съдържа членове, методи, заедно с дефиниция и реализация. [Клас]
//
// Набор от дефиниции, които трябва да се приложат. [Интерфейс]
//
//
//
// Посочете кое от изброените твърдение е вярно за интерфейсите в C#.
//
// Предоставя договор, определящ как да се създаде обект, без да се интересува от спецификата на това как обекта ще прави нещата., Това е референтен тип и включва само абстрактни членове като събития, методи, свойства и т.н. и няма реализации за нито един от своите членове.
//
//
//
//
// Дефинирайте понятието полиморфизъм в обектно-ориентираното програмиране като попълните липсващите думи в текста.
//
// Полиморфизмът в обектно-ориентираното програмиране представлява свойството на обектите от един и същи [тип] да имат един и същи [интерфейс], но с [различна реализация] на този [интерфейс]. „Един [интерфейс], [множество от различни реализации]“. Чрез полиморфизма се постига по-голяма [абстракция ] и по-лесно [повторно използване] на кода.
//
//
//
//
// Открийте липсващите думи в текста:
//
// Възможността референция към [базов клас ] да сочи обект както от базовия, така и обект от някой от производните класове е в основата на реализацията на [полиморфизма ] в езика C#.
//
// Кои от следните примери потвърждават това правило, ако имате следната йерархия class Cat : class Animal ?
//
// Cat cat = new Animal(); [не]
//
// Animal animal = new Animal(); [да]
//
// Animal animal = new Cat(); [да]
//
//
//
//
//
//
// Дайте пример за шаблонен клас, който да се казва Кутия (Box) и тази кутия да може да съхраняват всякакви елементи. В този клас създайте и един метод (Add), който да добавя елемент в края на редицата.
//
// class Box<T>
// {
// private List<T> items;
//
// public Box()
// {
// items = new List<T>();
// }
// public void Add(T item)
// {
// this.items.Add(item);
// }
// }
//
//
//
// Посочете кое от изброените е дефиниция на метод, който може да бъде презаписан в клас наследник.
// Виртуален метод.
//
//
//
//
// Дефинирайте понятието наследяване от обектно-ориентираното програмиране като попълните липсващите думи в текста.
//
// Наследяването е [основен принцип] от обектно-ориентираното програмиране. То позволява на един клас да "наследява" [поведение и характеристики] от друг, по-общ клас.
//
// В .NET и други модерни езици за програмиране един клас може да наследи [само един друг клас].
//
//
// Класът, който [дава ] своите членове на [дъщерния] си клас се нарича [базов] клас. А класът, който [получава] членове от [своя базов клас] - [подклас].
//
//
//
//
//
// Дефинирайте термина полиморфизъм в обектно-ориентираното програмиране, като поставите липсващите думи в текста.
//
// Терминът полиморфизъм в обектно-ориентираното програмиране определя, че [едни и същи (еднотипни)] действия се реализират по [различен начин] в зависимост от обектите, върху които се прилагат. Такива действия се наричат [полиморфични]. За да се реализира [полиморфно действие], класовете на обектите, върху които се прилага това действие, трябва да имат [общ корен] т.е. да бъдат производни на [един и същи клас].
//
//
//
//
//
// Обяснете основните разлики между презареждане и презаписване на методи.
//
// Методи с едно и също име, но различни сигнатури. [Презареждане на методи]
// Може да се случи в същия клас или в негов подклас. [Презареждане на методи]
// Може да се случи в подкласовете. [Презаписване на методи]
// Трябва да има същия тип на връщана стойност. [Презаписване на методи]
// При компилиране, според подадените параметри компилатора определя кой метод точно ще изпълни. [Презареждане на методи]
// Модификатора за достъп не може да бъде по-ограничаващ. [Презаписване на методи]
//
//
//
//
//
//
//
//
//
//
// ТЕСТ 5
//
//
//
// Посочете какво представлява и какво прави Current() от интерфейса IEnumerator:
// Current е свойството, което връща елемента от колекцията, който е на текущата позиция на итератора.
//
//
//
//
// Направете сравнение между IEnumerable и IEnumerator, като поставите липсващите думи в текста:
//
// IEnumerable се използва за [generic интерфейс], но IEnumerator се използва за [non‑generic интерфейс].
// IEnumerable има [само един метод], докато IEnumerator има [само два метода].
// IEnumerable [може да върне IEnumerator]. IEnumerator [не може да върне IEnumerable].
//
//
//
//
//
// Демонстрирайте как ще направите имплементацията на IComparable<T> като ви е предоставен следния фрагмент от код:
//
//
//
// class Point : [IComparable<Point>]
// {
// public int X { get; set; }
// public int Y { get; set; }
// public int [CompareTo(Point otherPoint)]
// {
// if (this.X != otherPoint.X)
// return (this.X - otherPoint.X);
//
// if (this.Y != otherPoint.Y)
// return (this.Y - otherPoint);
// return 0;
// }
// }
//
//
//
//
//
//
// Дефинирайте понятието функция, като попълните липсващите думи в текста.
//
// Функцията е [специално отношение], където на [всички входни данни] има [еднозначен изход].
//
//
//
//
// Имате следното парче код:
// Какво ще се случи след изпълнението на програмата? Ще се изведе ли нещо като резултат и какъв ще бъде той? Запишете вашия отговор в полето.
//
// На конзолата ще се отпечатат всички нечетни числа. 15 1 5 7
//
//
//
//
//
//
// Напишете програма, която въвежда цели числа разделени с ", ". Изведете четните числа в множеството, сортирани в низходящ ред.
//
// Изберете какъв тип на структури от данни ще използвате за решаване на този проблем. Използвайте функционален програмен филтър, сортирайте и отпечатайте на конзолата колекцията от числа на един ред разделени с ", ".
//
// За примерни входни/изходни данни ползвайте следните таблици:
//
// List<int> list = Console.ReadLine()
// .Split(", ", StringSplitOptions.RemoveEmptyEntries)
// .Select(int.Parse)
// .Where(x => x % 2 == 0)
// .OrderByDescending(x => x)
// .ToList();
//
// Console.WriteLine(string.Join(", ", list));
//
//
//
//
//
//
//
// Имате даден следния програмен фрагмент:
//
// int[] nums = { 1, 2, 3, 4, 5, 6 };
// nums = nums[.Where(num => num % 2 == 0)].ToArray();
//
// Коя от следните LINQ заявки и какъв ламбда израз ще използвате, за да филтрирате колекцията, така че тя да съдържа само четни числа?
//
//
//
//
// Имате даден следния програмен фрагмент:
//
// int[] nums = { 11, 99, 33, 55, 77, 44, 66, 22, 88 };
//
// nums = nums[.OrderBy(x => x)].ToArray();
// Коя от следните LINQ заявки ще използвате, за да подредите числата в колекцията във възходящ ред?
//
//
//
//
//
//
//
// Обяснете следния фрагмент от код с думи:
//
// int[] nums = { 1, 2, 3, 4, 5, 6 };
//
// int[] otherNums = { 7, 8, 9, 0 };
//
// nums = nums.Concat(otherNums);
//
//
// Console.WriteLine(string.Join(", ", nums));
//
// В полето запишете ред по ред какво прави кода и какво се очаква да получим като резултат.
//
//
//
// Инициализираме масив от цели числа nums и друг масив от цели числа otherNums.
//
// Конкатенираме (или слепваме) двата масива - масив otherNums се "залепя" след масива nums.
//
// Отпечатваме на конзолата елементите от масива на един ред разделени със ", ".
//
// Очакван резултат:
//
// 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
//
//
//
//
//
//
//
// Обяснете следния фрагмент от код с думи:
//
// List<int> list = new List<int>() { 20, 15, 1, 5, 7, 18, 66 };
//
// list.OrderByDescending(x => x).Take(3);
//
// Console.WriteLine(string.Join(", ", list));
//
// В полето запишете ред по ред какво прави кода и какво се очаква да получим като резултат.
//
//
//
// Инициализираме списък с цели числа.
//
// Сортираме числата от колекцията в низходящ ред и вземаме първите три числа от тях.
//
// Очакван резултат: 20, 15, 1, 5, 7, 18, 66
//
// Списъкът с числа си остава същия, защото OrderByDescending връща нов IOrderedEnumerable списък, а в дадения код не се презаписва новата подредба на числата върху предишния списък с числа.
//
//
//
//
//
//
//
//
// На конзолата ще ви бъдат подадени цели числа записани на един ред и разделени с интервал. Например: 5 7 12 56 24 3 8
//
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net8.0 is compatible. net8.0-android was computed. net8.0-browser was computed. net8.0-ios was computed. net8.0-maccatalyst was computed. net8.0-macos was computed. net8.0-tvos was computed. net8.0-windows was computed. net9.0 was computed. net9.0-android was computed. net9.0-browser was computed. net9.0-ios was computed. net9.0-maccatalyst was computed. net9.0-macos was computed. net9.0-tvos was computed. net9.0-windows was computed. net10.0 was computed. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.
-
net8.0
- No dependencies.
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories
This package is not used by any popular GitHub repositories.
| Version | Downloads | Last Updated |
|---|---|---|
| 1.0.0 | 106 | 5/20/2026 |