ahah

[jack1234567896]

public interface IAuthor { void AddAuthor(Author author); void EditAuthor(Author author); void DeleteAuthor(Guid authorId); void AddProduct(Guid authorId, Product product); void DeleteProduct(Guid authorId, Guid productId); Author GetAuthorById(Guid authorId); }

//author class using System; using System.Collections.Generic; using System.Text.RegularExpressions;

public enum Gender { Female, Male } public enum Country { Hungary, USA, UK, Germany } public enum City { Budapest, NewYork, London, Berlin }

public class Author : IAuthor, IComparable { public Guid Id { get; private set; } public string FirstName { get; private set; } public string LastName { get; private set; } public Gender Gender { get; private set; } public string PersonalNumber { get; private set; } public DateTime DateOfBirth { get; private set; } public Country Country { get; private set; } public City City { get; private set; } public string PhoneNumber { get; private set; } public string Email { get; private set; } public List Products { get; private set; }

public Author(string firstName, string lastName, Gender gender, string personalNumber, DateTime dateOfBirth, Country country, City city, string phoneNumber, string email)
{
    Id = Guid.NewGuid();
    SetFirstName(firstName);
    SetLastName(lastName);
    SetGender(gender);
    SetPersonalNumber(personalNumber);
    SetDateOfBirth(dateOfBirth);
    SetCountry(country);
    SetCity(city);
    SetPhoneNumber(phoneNumber);
    SetEmail(email);
    Products = new List<Product>();
}

public void SetFirstName(string firstName)
{
    if (string.IsNullOrEmpty(firstName) || firstName.Length < 2 || firstName.Length > 50)
        throw new ArgumentException("First name must be between 2 and 50 characters.");
    FirstName = firstName;
}

public void SetLastName(string lastName)
{
    if (string.IsNullOrEmpty(lastName) || lastName.Length < 2 || lastName.Length > 50)
        throw new ArgumentException("Last name must be between 2 and 50 characters.");
    LastName = lastName;
}

public void SetGender(Gender gender)
{
    Gender = gender;
}

public void SetPersonalNumber(string personalNumber)
{
    if (!Regex.IsMatch(personalNumber, @"^\d{11}$"))
        throw new ArgumentException("Personal number must be exactly 11 digits.");
    PersonalNumber = personalNumber;
}

public void SetDateOfBirth(DateTime dateOfBirth)
{
    if ((DateTime.Now.Year - dateOfBirth.Year) < 18)
        throw new ArgumentException("Author must be at least 18 years old.");
    DateOfBirth = dateOfBirth;
}

public void SetCountry(Country country)
{
    Country = country;
}

public void SetCity(City city)
{
    City = city;
}

public void SetPhoneNumber(string phoneNumber)
{
    if (string.IsNullOrEmpty(phoneNumber) || phoneNumber.Length < 4 || phoneNumber.Length > 50)
        throw new ArgumentException("Phone number must be between 4 and 50 characters.");
    PhoneNumber = phoneNumber;
}

public void SetEmail(string email)
{
    if (!Regex.IsMatch(email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
        throw new ArgumentException("Email is not valid.");
    Email = email;
}

public void AddAuthor(Author author)
{

}

public void EditAuthor(Author author)
{

}

public void DeleteAuthor(Guid authorId)
{

}

public void AddProduct(Guid authorId, Product product)
{

}

public void DeleteProduct(Guid authorId, Guid productId)
{

}

public Author GetAuthorById(Guid authorId)
{

    return this; 
}

public int CompareTo(Author other)
{
    return other.DateOfBirth.CompareTo(this.DateOfBirth); // Descending order by age
}

}

//product class using System; using System.Text.RegularExpressions;

public enum ProductType { Book, Article, ElectronicResource } public enum Publisher { PublisherA, PublisherB, PublisherC }

public class Product : IComparable { public Guid Id { get; private set; } public string Name { get; private set; } public string Annotation { get; private set; } public ProductType Type { get; private set; } public string ISBN { get; private set; } public DateTime ReleaseDate { get; private set; } public Publisher Publisher { get; private set; } public int NumberOfPages { get; private set; } public string Address { get; private set; }

public Product(string name, string annotation, ProductType type, string isbn, DateTime releaseDate, Publisher publisher, int numberOfPages, string address)
{
    Id = Guid.NewGuid();
    SetName(name);
    SetAnnotation(annotation);
    SetType(type);
    SetISBN(isbn);
    SetReleaseDate(releaseDate);
    SetPublisher(publisher);
    SetNumberOfPages(numberOfPages);
    SetAddress(address);
}

public void SetName(string name)
{
    if (string.IsNullOrEmpty(name) || name.Length < 2 || name.Length > 250)
        throw new ArgumentException("Name must be between 2 and 250 characters.");
    Name = name;
}

public void SetAnnotation(string annotation)
{
    if (string.IsNullOrEmpty(annotation) || annotation.Length < 100 || annotation.Length > 500)
        throw new ArgumentException("Annotation must be between 100 and 500 characters.");
    Annotation = annotation;
}

public void SetType(ProductType type)
{
    Type = type;
}

public void SetISBN(string isbn)
{
    if (!Regex.IsMatch(isbn, @"^\d{13}$"))
        throw new ArgumentException("ISBN must be exactly 13 digits.");
    ISBN = isbn;
}

public void SetReleaseDate(DateTime releaseDate)
{
    ReleaseDate = releaseDate;
}

public void SetPublisher(Publisher publisher)
{
    Publisher = publisher;
}

public void SetNumberOfPages(int numberOfPages)
{
    NumberOfPages = numberOfPages;
}

public void SetAddress(string address)
{
    if (string.IsNullOrEmpty(address))
        throw new ArgumentException("Address cannot be empty.");
    Address = address;
}

public int CompareTo(Product other)
{
    return this.NumberOfPages.CompareTo(other.NumberOfPages); 
}

}

//Statistical Class using System; using System.Collections.Generic; using System.Linq;

public class Statistics { public List Authors { get; private set; }

public Statistics()
{
    Authors = new List<Author>();
}

public void AddAuthor(Author author)
{
    Authors.Add(author);
}

public List<Author> GetAuthorsSortedByAgeDescending()
{
    return Authors.OrderByDescending(a => a.DateOfBirth).ToList();
}

public List<Product> GetProductsSortedByPageCountAscending()
{
    return Authors.SelectMany(a => a.Products).OrderBy(p => p.NumberOfPages).ToList();
}

public List<Product> GetProductsByDateRange(DateTime startDate, DateTime endDate)
{
    return Authors.SelectMany(a => a.Products).Where(p => p.ReleaseDate >= startDate && p.ReleaseDate <= endDate).ToList();
}

public List<Product> GetTopMProductsByCirculation(int m)
{

    return Authors.SelectMany(a => a.Products).OrderByDescending(p => p.NumberOfPages).Take(m).ToList();
}

public Dictionary<string, int> GetAnnualReport(int year)
{
    var products = Authors.SelectMany(a => a.Products).Where(p => p.ReleaseDate.Year == year).ToList();
    var report = new Dictionary<string, int>
    {
        { "Books", products.Count(p => p.Type == ProductType.Book) },
        { "Articles", products.Count(p => p.Type == ProductType.Article) },
        { "ElectronicResources", products.Count(p => p.Type == ProductType.ElectronicResource) }
    };
    return report;
}

}

IA ავტორის ინტერფეისი მიზანი:

აბსტრაქცია: IAuthor ინტერფეისი უზრუნველყოფს აბსტრაქტულ ფენას, რომელიც განსაზღვრავს ავტორის მენეჯმენტთან დაკავშირებულ ოპერაციებს იმის დაზუსტების გარეშე, თუ როგორ უნდა განხორციელდეს ეს ოპერაციები. ეს საშუალებას გაძლევთ განახორციელოთ ერთი და იგივე ინტერფეისი, რაც ხელს უწყობს მოქნილობას და მასშტაბურობას. ინკაფსულაცია: ინტერფეისის გამოყენებით, ჩვენ ვმალავთ ავტორის მართვის დეტალებს ინტერფეისის მომხმარებლებისგან, გამოვავლენთ მხოლოდ იმ მეთოდებს, რომლებიც აუცილებელია სისტემასთან ურთიერთობისთვის.

ავტორის კლასი ველები და დადასტურებები: კაფსულაცია: პირადი ველები საჯარო მეთოდებით: ავტორი კლასი იყენებს პრივატულ ველებს საჯარო მეთოდებით (setters) მნიშვნელობების დასაყენებლად. ეს უზრუნველყოფს, რომ ველების ყველა ცვლილება გაივლის ვალიდაციას, იცავს ობიექტის შიდა მდგომარეობას არასწორი მონაცემებისგან. GUID: გლობალურად უნიკალური იდენტიფიკატორი უზრუნველყოფს ავტორის თითოეული ობიექტის განსხვავებულობას, რაც გადამწყვეტია მონაცემთა ბაზის ერთეულების მართვისთვის. სახელი და გვარი: ეს ველები შეფუთულია ვალიდაციის ლოგიკით, მონაცემთა მთლიანობის უზრუნველსაყოფად. სიგრძის შემოწმება უზრუნველყოფს, რომ სახელები გონივრულ დიაპაზონშია. სქესი (ENUM): Enums ზღუდავს მნიშვნელობებს წინასწარ განსაზღვრულ ვარიანტებზე, რაც ხელს უშლის მონაცემთა არასწორი შეყვანას. PersonalNumber: ვალიდაცია უზრუნველყოფს, რომ პირადი ნომერი ზუსტად 11 ციფრია, ეროვნული საიდენტიფიკაციო ნომრების მსგავსი. დაბადების თარიღი: ვალიდაცია უზრუნველყოფს ავტორის მინიმუმ 18 წლის ასაკს, რაც შეიძლება იყოს კანონიერი მოთხოვნა ავტორებისთვის. ქვეყანა და ქალაქი (ENUM): ქვეყნისა და ქალაქისთვის ნომრების გამოყენება უზრუნველყოფს მხოლოდ მოქმედი მნიშვნელობების გამოყენებას, რაც ამარტივებს მონაცემთა ვალიდაციას და თანმიმდევრულობას. ტელეფონის ნომერი და ელფოსტა: ორივეს აქვს ფორმატისა და სიგრძის ვალიდაცია, რათა უზრუნველყოს ისინი სწორი და გონივრულ ფარგლებში. მეთოდები:

დაყენების მეთოდები: შეავსეთ მნიშვნელობების დაყენების ლოგიკა, მათ შორის ვალიდაცია. ეს უზრუნველყოფს ველებს მხოლოდ მოქმედი მონაცემების მინიჭებას. პროდუქტები (სია<პროდუქტი>): წარმოადგენს კომპოზიციურ ურთიერთობას, სადაც ავტორს აქვს პროდუქტის ობიექტების კოლექცია. ეს აჩვენებს, რომ პროდუქტის ობიექტები დამოუკიდებლად ვერ იარსებებს ავტორის გარეშე. განხორციელებული ინტერფეისები:

IAuthor: უზრუნველყოფს, რომ ავტორი კლასი უზრუნველყოფს იმპლემენტაციას ავტორების დამატების, რედაქტირების, წაშლისა და მათი პროდუქტების მართვისთვის. IComparable: საშუალებას აძლევს ავტორებს შეადარონ მათი დაბადების თარიღის მიხედვით, რაც გამოსადეგია დახარისხებისთვის.

პროდუქტის კლასი ველები და დადასტურებები:

კაფსულაცია: GUID: უზრუნველყოფს თითოეულ პროდუქტს აქვს უნიკალური იდენტიფიკატორი, რომელიც აუცილებელია სხვადასხვა პროდუქტის განსხვავებისთვის. დასახელება და ანოტაცია: ველები შეფუთულია დადასტურებით, რათა უზრუნველყოს აღწერილობითი, მაგრამ ლაკონური ჩანაწერები. ტიპი (ENUM): ზღუდავს პროდუქტის ტიპებს წინასწარ განსაზღვრულ ვარიანტებზე, რაც უზრუნველყოფს მონაცემთა თანმიმდევრულობას. ISBN: ვალიდაცია უზრუნველყოფს, რომ ISBN არის ზუსტად 13 ციფრი, სტანდარტის შესაბამისად. გამოშვების თარიღი: სავალდებულოა თვალყური ადევნოთ როდის გამოქვეყნდა პროდუქტი. გამომცემელი (ENUM): ზღუდავს გამომცემელს წინასწარ განსაზღვრულ ვარიანტებზე. NumberOfPages: თვალყურს ადევნებს პროდუქტის სიგრძეს. მისამართი: ტიპის მიხედვით, მას აქვს ფიზიკური მისამართი ან URL, რაც უზრუნველყოფს თითოეული პროდუქტის მდებარეობას. მეთოდები:

დაყენების მეთოდები: შეავსეთ მნიშვნელობების დაყენების ლოგიკა, მათ შორის ვალიდაცია, რათა უზრუნველყოფილი იყოს მხოლოდ სწორი მონაცემების მინიჭება. CompareTo: ახორციელებს IComparable ინტერფეისს, რათა პროდუქტები დალაგდეს გვერდების რაოდენობის მიხედვით.

სტატისტიკური კლასი მიზანი: Encapsulation: მართავს ავტორის ობიექტების კრებულს და უზრუნველყოფს სხვადასხვა სტატისტიკური ანალიზისა და დახარისხების მეთოდებს, ამ ოპერაციების ერთ კლასში ჩასმა. აბსტრაქცია: უზრუნველყოფს ოპერაციების შესრულების მეთოდებს, როგორიცაა დახარისხება, თარიღის დიაპაზონის ძიება და წლიური ანგარიშები მონაცემთა სტრუქტურის გამოვლენის გარეშე.

OOP პრინციპები გამოიყენება კაფსულაცია:

პირადი ველები საჯარო მეთოდებით: ავტორის და პროდუქტის კლასი იყენებს კერძო ველებს საჯარო მეთოდებით, რათა გააკონტროლონ წვდომა და უზრუნველყონ მონაცემთა მთლიანობა ვალიდაციის გზით. Validation Logic: ჩასმულია სეტერის მეთოდებში, რათა დარწმუნდეს, რომ ნებისმიერი მინიჭება ველებზე მოქმედებს. პოლიმორფიზმი:

ინტერფეისები (IAuthor, IComparable): მიეცით საშუალება სხვადასხვა იმპლემენტაცია განიხილებოდეს, როგორც ერთი და იგივე ტიპის. მაგალითად, ავტორი კლასის მართვა შესაძლებელია IAuthor ინტერფეისის მეშვეობით და ნებისმიერი კლასის განმახორციელებელი IAuthor შეიძლება გამოყენებულ იქნას ურთიერთშენაცვლებით. IComparable ინტერფეისი: საშუალებას აძლევს ავტორისა და პროდუქტის ობიექტების დალაგებას CompareTo მეთოდით განსაზღვრული მორგებული ლოგიკის გამოყენებით. მემკვიდრეობა:

ინტერფეისები: მიუხედავად იმისა, რომ ტრადიციული მემკვიდრეობა (extens-ის ან მემკვიდრეობის გამოყენებით) ცალსახად არ გამოიყენება, ინტერფეისების დანერგვა (IAuthor და IComparable) იძლევა მემკვიდრეობის ფორმას, სადაც კლასმა უნდა უზრუნველყოს ინტერფეისებში განსაზღვრული მეთოდების დანერგვა. აბსტრაქცია:

ინტერფეისები: მიაწოდეთ აბსტრაქტული ფენა, რომელიც განსაზღვრავს რა ოპერაციებს შეიძლება შესრულდეს ისე, თუ როგორ უნდა შესრულდეს ისინი. სტატისტიკური კლასი: აბსტრაქტებს დახარისხების, ძიების და მოხსენების ოპერაციებს, რაც უზრუნველყოფს მარტივ ინტერფეისს ამ ოპერაციებისთვის. შემადგენლობა:

ავტორისა და პროდუქტის ურთიერთობა: აჩვენებს კომპოზიციურ ურთიერთობას, სადაც ავტორის ობიექტს აქვს პროდუქტის ობიექტების კოლექცია. ეს ნიშნავს, რომ პროდუქტის ობიექტები დამოკიდებულნი არიან ავტორის ობიექტზე და არ შეუძლიათ დამოუკიდებლად არსებობა.

[JhonKunuga]

Merge that

[JhonKunuga]

Make The One File If possible

[jack1234567896]

c#.txt.zip