Jak funguje OOP v C# .NET?

Question

Dobrý den, potřeboval bych poradit jak funguje klasické OOP v C# .NET a prosím ještě jak se používá funkce LINQ.

Answer 1

using System;

namespace DnsExercise

{

public class Program

{

    static void Main(string[] args)

    {

        // Vytvoření instance validátoru IP adres

        IIpAddressValidator ipValidator = new IpAddressValidator();

        // Příklad využití rozhraní (interface) pro dosažení flexibilního a udržovatelného kódu

        // Díky závislosti na rozhraní můžeme snadno zaměnit implementaci validátoru

        // Například při testování můžeme použít falešný validátor, který vždy vrací true

        // IIpAddressValidator ipValidator = new FakeIpAddressValidator();

        // Vytvoření instance DNS serveru s názvem a validátorem IP adres

        DnsServer server = new DnsServer("Můj server", ipValidator);

        // Přidání záznamů do DNS serveru

        server.AddRecord("google.com", "8.8.8.8"); // Platná IP adresa

        server.AddRecord("špatná-adresa.com", "xy.00.100.0"); // Neplatná IP adresa

        server.AddRecord("facebook.com", "168.100.100.0"); // Platná IP adresa

        server.AddRecord("špatná-adresa-2.com", "260.100.100.0"); // Neplatná IP adresa

        // Zobrazení všech uložených záznamů v DNS serveru

        server.DisplayAllRecords();

    }

}

}

using System.Text.RegularExpressions;

namespace DnsExercise

{

/// <summary>

/// Třída pro validaci IPv4 adres pomocí regulárního výrazu.

/// Implementuje rozhraní IIpAddressValidator.

/// </summary>

public class IpAddressValidator : IIpAddressValidator

{

    private Regex IpRegex;

    public IpAddressValidator()

    {

        // Inicializace regulárního výrazu pro validaci IPv4 adres.

        // Tento regex ověřuje, že adresa má formát "A.B.C.D", kde A až D jsou čísla v rozsahu 0–255.

        IpRegex = new Regex(@"^((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])\.){3}"

                          + @"(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])$");

        /*

         * Vysvětlení regulárního výrazu:

         * 

         * ^ a $ – Značí začátek a konec řetězce, zajišťují, že celý řetězec odpovídá vzoru.

         * 

         * ((...)\.){3} – Tato část se opakuje třikrát a odpovídá prvním třem oktetům IP adresy, každý zakončený tečkou.

         * 

         * (25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9]) – Tato část odpovídá jednotlivému oktetu IP adresy:

         *   - 25[0-5]: Čísla 250 až 255.

         *   - 2[0-4][0-9]: Čísla 200 až 249.

         *   - 1[0-9]{2}: Čísla 100 až 199.

         *   - [1-9]?[0-9]: Čísla 0 až 99, přičemž čísla 0 až 9 mohou mít volitelnou vedoucí nulu.

         * 

         * Celkově regex ověřuje, že IP adresa má čtyři části oddělené tečkami, přičemž každá část je číslo v rozsahu 0 až 255.

         */

    }

    /// <summary>

    /// Metoda pro ověření, zda zadaný řetězec je platná IPv4 adresa.

    /// </summary>

    /// <param name="address">Řetězec obsahující IP adresu.</param>

    /// <returns>True, pokud je adresa platná; jinak false.</returns>

    public bool Validate(string address)

    {

        return IpRegex.IsMatch(address);

    }

}

}

namespace DnsExercise

{

/// <summary>

/// Rozhraní pro validaci IP adres.

/// Definuje kontrakt, který musí implementovat každá třída provádějící validaci IP adres.

/// </summary>

public interface IIpAddressValidator

{

    /// <summary>

    /// Metoda pro ověření, zda zadaný řetězec je platná IP adresa.

    /// </summary>

    /// <param name="address">Řetězec obsahující IP adresu.</param>

    /// <returns>True, pokud je adresa platná; jinak false.</returns>

    bool Validate(string address);

}

}

namespace DnsExercise

{

public class FakeIpAddressValidator : IIpAddressValidator

{

    public bool Validate(string address)

    {

        return true; // Vždy vrací true, nezávisle na obsahu adresy

    }

}

}

///////trida DNS exercise

namespace DnsExercise
{
    /// <summary>
    /// Třída reprezentující DNS server.
    /// </summary>
    public class DnsServer
    {
        private readonly IIpAddressValidator _ipAddressValidator;

        /// <summary>
        /// Uživatelsky přívětivý název serveru.
        /// </summary>
        public string FriendlyName { get; set; }

        /// <summary>
        /// Seznam DNS záznamů spravovaných serverem.
        /// </summary>
        public List<DnsRecord> Records { get; set; }

        /// <summary>
        /// Konstruktor třídy DnsServer.
        /// Inicializuje název serveru, validátor IP adres a seznam záznamů.
        /// </summary>
        /// <param name="friendlyName">Uživatelsky přívětivý název serveru.</param>
        /// <param name="ipAddressValidator">Instance validátoru IP adres.</param>
        public DnsServer(string friendlyName, IIpAddressValidator ipAddressValidator)
        {
            FriendlyName = friendlyName;
            _ipAddressValidator = ipAddressValidator;
            Records = new List<DnsRecord>();
        }

        /// <summary>
        /// Přidá nový DNS záznam do serveru.
        /// Před přidáním ověřuje platnost IP adresy.
        /// </summary>
        /// <param name="domainName">Doménové jméno.</param>
        /// <param name="ipAddress">IP adresa.</param>
        public void AddRecord(string domainName, string ipAddress)
        {
            // Ověření platnosti IP adresy
            if (!_ipAddressValidator.Validate(ipAddress))
            {
                Console.WriteLine($"IP adresa '{ipAddress}' není platná.");
                return;
            }

            // Vytvoření nového DNS záznamu
            DnsRecord dnsRecord = new DnsRecord(domainName, ipAddress);
            Records.Add(dnsRecord);
            Console.WriteLine($"Záznam pro '{domainName}' přidán.");
        }

        /// <summary>
        /// Zobrazí všechny DNS záznamy serveru.
        /// </summary>
        public void DisplayAllRecords()
        {
            Console.WriteLine($"DNS záznamy pro server '{FriendlyName}':");
            foreach (DnsRecord record in Records)
            {
                record.DisplayRecord();
            }
        }

        /// <summary>
        /// Najde DNS záznam podle doménového jména.
        /// </summary>
        /// <param name="name">Doménové jméno.</param>
        /// <returns>DNS záznam nebo null, pokud nebyl nalezen.</returns>
        public DnsRecord? FindRecord(string name)
        {
            return Records.FirstOrDefault(r => r.DomainName.Equals(name, StringComparison.OrdinalIgnoreCase));
        }
    }
}

namespace DnsExercise
{
    /// <summary>
    /// Třída reprezentující DNS záznam.
    /// </summary>
    public class DnsRecord
    {
        /// <summary>
        /// Doménové jméno (např. "google.com").
        /// </summary>
        public string DomainName { get; set; }
        /// <summary>
        /// IP adresa přiřazená k doménovému jménu (např. "8.8.8.8").
        /// </summary>
        public string IpAddress { get; set; }
        /// <summary>
        /// Konstruktor třídy DnsRecord.
        /// Inicializuje doménové jméno a IP adresu.
        /// </summary>
        /// <param name="domainName">Doménové jméno.</param>
        /// <param name="ipAddress">IP adresa.</param>
        public DnsRecord(string domainName, string ipAddress)
        {
            DomainName = domainName;
            IpAddress = ipAddress;
        }
        /// <summary>
        /// Zobrazí DNS záznam ve formátu "doménové jméno: IP adresa".
        /// </summary>
        public void DisplayRecord()
        {
            Console.WriteLine($"DNS Record: {DomainName}:{IpAddress}");
        }
    }
}