Gyakorlat – Kód összeállítása metódusokkal

10 perc

A metódusok hasznosak a kód rendszerezéséhez, a kód újrafelhasználásához és a problémák hatékony kezeléséhez. Olyan metódusra is gondolhat, mint egy fekete doboz, amely bemenetet vesz fel, végrehajtja a megnevezett feladatot, és kimenetet ad vissza. Ezzel a feltételezéssel gyorsan strukturálhatja a programokat úgy, hogy a feladatokat metódusként nevezi el, majd az összes szükséges feladat azonosítása után kitölti a logikát.

Ha egyszerű nyelven írja le a kód lépéseit, anélkül, hogy szigorúan betartja a szintaxisszabályokat, akkor "pszeudokódot" használ. A metódusok és a pszeudokódok kombinálásával gyorsan átélheti a kihívást jelentő programozási feladatokat.

Metódusok használata a kód strukturálásához

Tegyük fel, hogy egy kódolási interjúban jelölt. A kérdező azt szeretné, hogy írjon egy programot, amely ellenőrzi, hogy egy IPv4-cím érvényes vagy érvénytelen. A következő szabályokat kapja:

Az érvényes IPv4-címek négy számból állnak, pontokkal elválasztva
Minden szám nem tartalmazhat kezdő nullákat
Minden számnak 0 és 255 között kell lennie

Az 1.1.1.1 és a 255.255.255.255 példa érvényes IP-címekre.

Az IPv4-cím sztringként van megadva. Feltételezheti, hogy csak számjegyekből és pontból áll (a sztringben nincsenek betűk).

Hogyan közelítené meg ezt a feladatot?

Feljegyzés

Még ha nem is ismeri az IP-címeket, ne aggódjon! A gyakorlatban továbbra is végrehajthatja a kódot a lépések követésével.

A probléma lebontása

Ebben a feladatban azonosítja a probléma megoldásához szükséges lépéseket. Ha alaposan megvizsgálja a szabályokat, észreveheti, hogy csak három lépésből áll, hogy megállapítsa, érvényes-e egy IPv4-cím.

A Visual Studio Code Editorban törölje a meglévő kódot az előző gyakorlatokból.
Írja be a következő pszeudokódot a Szerkesztőbe:
```
/*
if ipAddress consists of 4 numbers
and
if each ipAddress number has no leading zeroes
and
if each ipAddress number is in range 0 - 255

then ipAddress is valid

else ipAddress is invalid
*/
```
A pszeudokód nagyszerű módja annak, hogy megkezdje a problémák kezelését. Ezzel a megjegyzésblokkdal áthidalhatja a parancssori szabályok és a programkód közötti szakadékot, tisztázva a kód által végrehajtandó főbb feladatokat. A pszeudokódnak nem kell funkcionálisnak lennie, és nem kell betartania a szintaxisszabályokat, azonban egyértelmű magyarázatnak kell lennie arra, hogy mit fog tenni a kód. Most alakítsuk ezt valódi kódmá!
Adjon meg egy új üres kódsort, majd írja be a következő kódot a Szerkesztőbe:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
Ebben a lépésben a if pszeudokódból származó utasításokat hívható metódusokká alakítja át, és kimeneteli az eredményeket. Ne aggódjon a metódusok definiálása miatt; feltételezheti, hogy minden metódus végrehajtja a neve által leírt feladatot. Hamarosan kijavíthatja a fordítási hibákat, és létrehozhatja a metóduslogikát, de egyelőre a nagy képre kell összpontosítania. Amikor elkezd dolgozni egy új programon, a teljes kialakításra összpontosítva segít a rendszerezettség megőrzésében és az alkalmazás gyorsabb fejlesztésében.
Írjon be egy új üres kódsort a meglévő kód alá, majd írja be a következő kódot a Szerkesztőbe:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Figyelje meg, hogy a helyőrző módszerek használatával gyorsan megközelítheti a problémát, és strukturálhatja a kódot a megoldás fejlesztéséhez. Most, hogy már rendelkezik egy strukturált tervvel, továbbra is megoldhatja a problémát a kód darabonkénti kitöltésével.

A megoldás fejlesztése

Most, hogy már rendelkezik a probléma megoldásához szükséges helyőrző módszerekkel, elkezdheti a megoldás részleteire összpontosítani. Ne feledje, hogy az IPv4-cím bemeneti formátuma pontokkal elválasztott számjegyekből álló sztring lesz. Lássunk hozzá!

A program elején hozzon létre változókat a bemeneti és érvényesítési állapotok tárolásához:

string ipv4Input = "107.31.1.5";
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Frissítse a megoldáskódot az érvényesítési változók használatára az alábbiak szerint:

ValidateLength(); 
ValidateZeroes(); 
ValidateRange();

if (validLength && validZeroes && validRange) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}

Frissítse a metódust az ValidateLength alábbiak szerint:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
Az első szabály szerint az IPv4-címnek négy számmal kell rendelkeznie. Ebben a kódban tehát elkülönítheti string.Split a számjegyeket, és ellenőrizheti, hogy négy van-e belőlük.
Frissítse a metódust az ValidateZeroes alábbiak szerint:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
        }
    }

    validZeroes = true;
}
```
Szánjon egy kis időt, hogy átgondolja, hogyan fordítja le a szabály a kódot.

A második szabály szerint az IPv4-címben szereplő számok nem tartalmazhatnak kezdő nullákat. A metódusnak tehát ellenőriznie kell a kezdő nullák számát, miközben érvényes számként fogadja el 0 . Ha az összes szám érvényes nullával rendelkezik, validZeroes akkor egyenlőnek truekell lennie, és false ellenkező esetben. Ebben a kódban tehát ellenőrzi, hogy az egynél több számjegyet tartalmazó számok nem nullával kezdődnek-e.

Ha alaposan megtekinti, láthatja, hogy validZeroes a ciklus befejeződése után be true van állítvaforeach. Azonban csak akkor szeretné beállítani validZeroes , true ha nem található kezdő nulla. Ezt a hibát kijavíthatja úgy, hogy a validZeroes = true ciklus futtatása előtt be van állítvaforeach. Ezt a hibát azonban egy visszatérési utasítással is kijavíthatja.
Frissítse a kódot a következőre:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
A visszatérési utasítás leállítja a metódus végrehajtását, és visszaadja a vezérlést a metódushívónak. return Az első érvénytelen nulla megtalálása után az utasítás hozzáadása az validZeroes = false első érvénytelen nulla után leállítja a metódust. Ha nem található érvénytelen nulla, a metódus a beállítás validZeroestrueután leáll. Térjünk át a következő metódusra.
Frissítse a metódust az ValidateRange alábbiak szerint:
```
void ValidateRange() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}
```
A harmadik szabály azt állítja, hogy az IPv4-címek minden számának 0 és 255 közötti tartományba kell esnie. Ebben a kódban tehát ellenőrzi, hogy minden szám kisebb-e 255-nél, és ha nem, a végrehajtás leállítása a beállítás validRangefalseután. Mivel a bemeneti sztring csak számjegyeket és elemet tartalmaz, nem kell negatív számokat keresnie.

Előfordulhat azonban olyan eset, amikor a pont között nincsenek számjegyek. Például: "255...255". Ebben az esetben string.Split(".") üres bejegyzéseket ad vissza, ami int.Parse sikertelenséghez vezet. Ezt a beállítás megadásával megakadályozhatja StringSplitOptions.
Frissítse a kódot az alábbiak szerint:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
A tömb üres bejegyzéseinek kihagyása StringSplitOptions.RemoveEmptyEntries és az address üres sztringek elemzésének megakadályozása.

A megoldás befejezése

Most, hogy elvégezte az IP-címek érvényesítéséhez szükséges összes metódust, ideje újra áttekinteni a kezdeti megoldást. Ebben a feladatban további bemeneti értékeket fog hozzáadni, és felkészül a kód tesztelésére.

Keresse meg a program korábbi részében írt alábbi kódot:
```
string ipv4Input = "107.31.1.5";
```
Frissítse a kódot az alábbiak szerint:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Megoldás fejlesztésekor fontos a kód tesztelése különböző bemeneti esetekkel. Ebben a kódban a tesztelési értékek megfelelő tartományát adja meg. Most, hogy frissítette a tesztbemenetet, frissítenie kell a kódot az új értékek használatához. Mivel az értékek egy tömbben találhatók, frissítenie kell a kódot, hogy mindegyiket egy hurok használatával tesztelje.
Frissítse a kódot az alábbiak szerint:
```
foreach (string ip in ipv4Input) 
{
    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}
```
Végül ki kell javítania az egyes metódusok által használt bemeneti adatokat, mivel sztringről tömbre frissült ipv4Input . Mivel minden metódus használ string.Split, deklarálhat egy változót az eredmény string.Split tárolásához és az egyes metódusokban való használatához.

Adjon hozzá egy változót az egyes metódusok által hivatkozott aktuális IPv4-cím tárolásához:

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Inicializálás addressstring.Split a következőképpen:

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

Távolítsa el az egyes érvényesítési módszerekre string.Split mutató hivatkozásokat, hogy ehelyett a globális address változót használják. Példa:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

A munka ellenőrzése

Ebben a feladatban futtatja az alkalmazást az integrált terminálról, és ellenőrzi, hogy a kód megfelelően működik-e. Lássunk neki!

Hasonlítsa össze a kódot a következőkkel, hogy biztosan helyes legyen:

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}

void ValidateLength() 
{
    validLength = address.Length == 4;
};

void ValidateZeroes() 
{
    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
            return;
        }
    }

    validZeroes = true;
}

void ValidateRange() 
{
    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}

Mentse a munkáját a CtrlS + vagy a Visual Studio Code File menüvel.
Szükség esetén nyissa meg a Visual Studio Code integrált terminálpaneljét.

Az EXPLORER panelen nyissa meg a Terminált a TestProject mappa helyén, kattintson a jobb gombbal a TestProject elemre, majd válassza a Megnyitás az integrált terminálban lehetőséget.
A Terminál parancssorában írja be a dotnet run
Ellenőrizze, hogy a kód a következő kimenetet hozza-e létre:
```
107.31.1.5 is a valid IPv4 address
255.0.0.255 is a valid IPv4 address
555..0.555 is an invalid IPv4 address
255...255 is an invalid IPv4 address
```
Ha a kód eltérő eredményeket jelenít meg, a hiba megkereséséhez és a frissítések elvégzéséhez át kell tekintenie a kódot. Futtassa újra a kódot, és ellenőrizze, hogy kijavította-e a problémát. Folytassa a kód frissítését és futtatását, amíg a kód meg nem hozza a várt eredményeket.

Összefoglalás

Az eddigi módszerek használatáról az alábbiakat tanulta:

A metódusokkal gyorsan strukturálhatók az alkalmazások
A return kulcsszó használható a metódus végrehajtásának leállításához
A probléma minden lépése gyakran lefordítható a saját módszerére
Módszerek használata kis problémák megoldására a megoldás létrehozásához

Visszajelzés

Hasznosnak találta ezt az oldalt?