C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IPAdresse
{
    class Program
    {
        static void Main(string[] args)
        {
            string ipAdresse = null, ersteOktet = null, zweiteOktet = null, dritteOktet = null, vierteOktet = null, cidr = null;
            bool ipOhneFehler = false;
            int z = 0;

            Random r = new Random();
            var consoleColors = Enum.GetValues(typeof(ConsoleColor));

            do
            {
                Console.Clear();

                do
                {
                    Console.Clear();

                    foreach (char y in ("Geben Sie die IP-Adresse (Format: 192.168.0.0/24) ein: ").ToArray())
                    {
                        Console.Write(y);
                        Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                        var task = Task.Run(async delegate
                        {
                            await Task.Delay(44);
                            return 42;
                        });
                        task.Wait();
                    }

                    //Console.Write("Geben Sie die IP-Adresse (Format: 192.168.0.0/24) ein: ");
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    ipAdresse = Console.ReadLine();

                    foreach (char x in ipAdresse.ToArray())
                    {
                        if (int.TryParse(x.ToString(), out z) == false & x != '.' & x != '/')
                        {
                            foreach (char y in ("Ihre IP-Adresse besteht aus unerlaubten Symbole!!!(Symbol: " + x + ")").ToArray())
                            {
                                Console.Write(y);
                                Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                var task = Task.Run(async delegate
                                {
                                    await Task.Delay(44);
                                    return 42;
                                });
                                task.Wait();
                            }

                            Console.WriteLine();
                            ipOhneFehler = false;
                            //Console.ReadLine();
                        }
                        else ipOhneFehler = true;
                    }

                    Console.ReadLine();

                    if (ipOhneFehler)
                    {
                        ipOhneFehler = false;

                        try
                        {
                            String[] ip = ipAdresse.Split(new Char[] { ',', '.', '/' });
                            ersteOktet = ip[0]; zweiteOktet = ip[1]; dritteOktet = ip[2]; vierteOktet = ip[3]; cidr = ip[4];

                            if (Convert.ToInt32(ersteOktet) < 0 | Convert.ToInt32(ersteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 1 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }

                                Console.WriteLine();

                                //Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(zweiteOktet) < 0 | Convert.ToInt32(zweiteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 2 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }

                                Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(dritteOktet) < 0 | Convert.ToInt32(dritteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 3 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }

                                Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(vierteOktet) < 0 | Convert.ToInt32(vierteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 4 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }

                                Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(cidr) < 0 | Convert.ToInt32(cidr) > 32)
                            {
                                foreach (char y in ("Es gibt Fehler im CIDR").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }

                                Console.WriteLine();
                                //Console.WriteLine("Es gibt Fehler im CIDR");
                                Console.ReadLine();
                            }
                            else ipOhneFehler = true;
                        }
                        catch (Exception)
                        {
                            foreach (char y in ("Es ist unmöglich aus dem eingegebenen String eine richtige IP-Adresse zu bekommen").ToArray())
                            {
                                Console.Write(y);
                                Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                var task = Task.Run(async delegate
                                {
                                    await Task.Delay(44);
                                    return 42;
                                });
                                task.Wait();
                            }

                            Console.WriteLine();
                            Console.ReadLine();
                        }
                    }
                } while (ipOhneFehler == false);

                foreach (char y in ("1 Oktet: " + ersteOktet + ", 2 Oktet: " + zweiteOktet + ", 3 Oktet: " + dritteOktet + ", 4 Oktet: " + vierteOktet + ", CIDR: " + cidr).ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }

                Console.WriteLine();

                //Console.WriteLine();

                foreach (char y in ("Ihre IP-Adresse lautet: " + ersteOktet + "." + zweiteOktet + "." + dritteOktet + "." + vierteOktet + "/" + cidr).ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }

                Console.WriteLine();

                //Console.WriteLine("Ihre IP-Adresse lautet: " + ersteOktet + "." + zweiteOktet + "." + dritteOktet + "." + vierteOktet + "/" + cidr);

                // Subnettingberechnung
                double sw = (Math.Pow(2, (8 - Convert.ToInt32(cidr) % 8)));
                int gz = 0, nid = 0, sm = 0, bc = 0;
                string netzwerkInfo = null, ipPräfix = null, ipSuffixStart = null, ipSuffixEnd = null;

                //Console.WriteLine(cidr + "/8= " + (Convert.ToInt32(cidr) / 8).ToString() + " und Rest: " + (Convert.ToInt32(cidr) % 8).ToString());

                if (Convert.ToInt32(cidr) >= 0 & Convert.ToInt32(cidr) < 8)
                {
                    ipPräfix = null;
                    ipSuffixStart = ".0.0.0";
                    ipSuffixEnd = ".255.255.255";

                    gz = Convert.ToInt32(ersteOktet) / Convert.ToInt32(sw);
                    nid = gz * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);

                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", nid.ToString() + ipSuffixStart, bc.ToString() + ipSuffixEnd, sm.ToString() + ipSuffixStart, ((256 * 256 * 256 * sw) - 2).ToString());
                    netzwerkInfo += "\n \nAdressbereiche der Größe /0 bis /7 werden in der Praxis nicht \nals einzelnes Subnetz verwendet, sondern in mehrere Subnetze unterteilt.";

                }
                else if (Convert.ToInt32(cidr) >= 8 & Convert.ToInt32(cidr) < 16)
                {
                    ipPräfix = ersteOktet + ".";
                    ipSuffixStart = ".0.0";
                    ipSuffixEnd = ".255.255";

                    gz = Convert.ToInt32(zweiteOktet) / Convert.ToInt32(sw);
                    nid = gz * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);

                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString() + ipSuffixStart, ipPräfix + bc.ToString() + ipSuffixEnd, "255." + sm.ToString() + ipSuffixStart, ((256 * 256 * sw) - 2).ToString());

                }
                else if (Convert.ToInt32(cidr) >= 16 & Convert.ToInt32(cidr) < 24)
                {
                    ipPräfix = ersteOktet + "." + zweiteOktet + ".";
                    ipSuffixStart = ".0";
                    ipSuffixEnd = ".255";

                    gz = Convert.ToInt32(dritteOktet) / Convert.ToInt32(sw);
                    nid = gz * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);

                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString() + ipSuffixStart, ipPräfix + bc.ToString() + ipSuffixEnd, "255.255." + sm.ToString() + ipSuffixStart, ((256 * sw) - 2).ToString());

                }
                else if (Convert.ToInt32(cidr) >= 24 & Convert.ToInt32(cidr) < 32)
                {
                    ipPräfix = ersteOktet + "." + zweiteOktet + "." + dritteOktet + ".";

                    gz = Convert.ToInt32(vierteOktet) / Convert.ToInt32(sw);
                    nid = Convert.ToInt32(gz) * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);

                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString(), ipPräfix + bc.ToString(), "255.255.255." + sm.ToString(), (sw - 2).ToString());

                    if (cidr == "31") netzwerkInfo += netzwerkInfo += "\n \n/31-Netze enthalten keine nutzbaren Host-Adressen, \nwährend /32 kein Subnetz, sondern immer einen einzelnen Host adressiert.\nHierbei gibt es auch Ausnahmen. \nSo wurde im RFC 3021 vorgeschlagen, \ndass /31-Netze genutzt werden, um Point-to-point-Verbindungen zu etablieren. \nDies wurde unter anderem von der Firma Cisco implementiert. Des Weiteren ist es \nunter bestimmten Umständen möglich, \ndie Netz- und Broadcastadresse für Hosts zu verwenden.";

                }
                else if (Convert.ToInt32(cidr) == 32)
                {
                    ipPräfix = ersteOktet + "." + zweiteOktet + "." + dritteOktet + ".";

                    gz = Convert.ToInt32(vierteOktet) / Convert.ToInt32(sw);
                    nid = Convert.ToInt32(vierteOktet);
                    bc = 255;
                    sm = 255;

                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString(), "KEIN", "255.255.255." + sm.ToString(), (2 - 2).ToString());

                    netzwerkInfo += "\n \n/31-Netze enthalten keine nutzbaren Host-Adressen, \nwährend /32 kein Subnetz, sondern immer einen einzelnen Host adressiert.\nHierbei gibt es auch Ausnahmen. \nSo wurde im RFC 3021 vorgeschlagen, \ndass /31-Netze genutzt werden, um Point-to-point-Verbindungen zu etablieren. \nDies wurde unter anderem von der Firma Cisco implementiert. Des Weiteren ist es \nunter bestimmten Umständen möglich, \ndie Netz- und Broadcastadresse für Hosts zu verwenden.";

                }

                else Console.WriteLine("Unerwartete Wert");

                foreach (char y in (netzwerkInfo).ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }

                Console.WriteLine();

                //Console.WriteLine(netzwerkInfo);

                Console.WriteLine();

                foreach (char y in ("Um Programm zu beenden, geben Sie 'exit' ein: ").ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }

                //Console.Write();

            } while (Console.ReadLine() != "exit");

        }
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace IPAdresse
{
    class Program
    {
        static void Main(string[] args)
        {
            string ipAdresse = null, ersteOktet = null, zweiteOktet = null, dritteOktet = null, vierteOktet = null, cidr = null;
            bool ipOhneFehler = false;
            int z = 0;
​
            Random r = new Random();
            var consoleColors = Enum.GetValues(typeof(ConsoleColor));
​
            do
            {
                Console.Clear();
​
                do
                {
                    Console.Clear();
​
                    foreach (char y in ("Geben Sie die IP-Adresse (Format: 192.168.0.0/24) ein: ").ToArray())
                    {
                        Console.Write(y);
                        Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                        var task = Task.Run(async delegate
                        {
                            await Task.Delay(44);
                            return 42;
                        });
                        task.Wait();
                    }
​
                    //Console.Write("Geben Sie die IP-Adresse (Format: 192.168.0.0/24) ein: ");
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    ipAdresse = Console.ReadLine();
​
                    foreach (char x in ipAdresse.ToArray())
                    {
                        if (int.TryParse(x.ToString(), out z) == false & x != '.' & x != '/')
                        {
                            foreach (char y in ("Ihre IP-Adresse besteht aus unerlaubten Symbole!!!(Symbol: " + x + ")").ToArray())
                            {
                                Console.Write(y);
                                Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                var task = Task.Run(async delegate
                                {
                                    await Task.Delay(44);
                                    return 42;
                                });
                                task.Wait();
                            }
​
                            Console.WriteLine();
                            ipOhneFehler = false;
                            //Console.ReadLine();
                        }
                        else ipOhneFehler = true;
                    }
​
                    Console.ReadLine();
​
                    if (ipOhneFehler)
                    {
                        ipOhneFehler = false;
​
                        try
                        {
                            String[] ip = ipAdresse.Split(new Char[] { ',', '.', '/' });
                            ersteOktet = ip[0]; zweiteOktet = ip[1]; dritteOktet = ip[2]; vierteOktet = ip[3]; cidr = ip[4];
​
                            if (Convert.ToInt32(ersteOktet) < 0 | Convert.ToInt32(ersteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 1 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }
​
                                Console.WriteLine();
​
                                //Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(zweiteOktet) < 0 | Convert.ToInt32(zweiteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 2 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }
​
                                Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(dritteOktet) < 0 | Convert.ToInt32(dritteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 3 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }
​
                                Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(vierteOktet) < 0 | Convert.ToInt32(vierteOktet) > 255)
                            {
                                foreach (char y in ("Es gibt Fehler im 4 Oktet").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }
​
                                Console.WriteLine();
                                Console.ReadLine();
                            }
                            else if (Convert.ToInt32(cidr) < 0 | Convert.ToInt32(cidr) > 32)
                            {
                                foreach (char y in ("Es gibt Fehler im CIDR").ToArray())
                                {
                                    Console.Write(y);
                                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                    var task = Task.Run(async delegate
                                    {
                                        await Task.Delay(44);
                                        return 42;
                                    });
                                    task.Wait();
                                }
​
                                Console.WriteLine();
                                //Console.WriteLine("Es gibt Fehler im CIDR");
                                Console.ReadLine();
                            }
                            else ipOhneFehler = true;
                        }
                        catch (Exception)
                        {
                            foreach (char y in ("Es ist unmöglich aus dem eingegebenen String eine richtige IP-Adresse zu bekommen").ToArray())
                            {
                                Console.Write(y);
                                Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                                var task = Task.Run(async delegate
                                {
                                    await Task.Delay(44);
                                    return 42;
                                });
                                task.Wait();
                            }
​
                            Console.WriteLine();
                            Console.ReadLine();
                        }
                    }
                } while (ipOhneFehler == false);
​
                foreach (char y in ("1 Oktet: " + ersteOktet + ", 2 Oktet: " + zweiteOktet + ", 3 Oktet: " + dritteOktet + ", 4 Oktet: " + vierteOktet + ", CIDR: " + cidr).ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }
​
                Console.WriteLine();
​
                //Console.WriteLine();
​
                foreach (char y in ("Ihre IP-Adresse lautet: " + ersteOktet + "." + zweiteOktet + "." + dritteOktet + "." + vierteOktet + "/" + cidr).ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }
​
                Console.WriteLine();
​
                //Console.WriteLine("Ihre IP-Adresse lautet: " + ersteOktet + "." + zweiteOktet + "." + dritteOktet + "." + vierteOktet + "/" + cidr);
​
                // Subnettingberechnung
                double sw = (Math.Pow(2, (8 - Convert.ToInt32(cidr) % 8)));
                int gz = 0, nid = 0, sm = 0, bc = 0;
                string netzwerkInfo = null, ipPräfix = null, ipSuffixStart = null, ipSuffixEnd = null;
​
                //Console.WriteLine(cidr + "/8= " + (Convert.ToInt32(cidr) / 8).ToString() + " und Rest: " + (Convert.ToInt32(cidr) % 8).ToString());
​
                if (Convert.ToInt32(cidr) >= 0 & Convert.ToInt32(cidr) < 8)
                {
                    ipPräfix = null;
                    ipSuffixStart = ".0.0.0";
                    ipSuffixEnd = ".255.255.255";
​
                    gz = Convert.ToInt32(ersteOktet) / Convert.ToInt32(sw);
                    nid = gz * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);
​
                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", nid.ToString() + ipSuffixStart, bc.ToString() + ipSuffixEnd, sm.ToString() + ipSuffixStart, ((256 * 256 * 256 * sw) - 2).ToString());
                    netzwerkInfo += "\n \nAdressbereiche der Größe /0 bis /7 werden in der Praxis nicht \nals einzelnes Subnetz verwendet, sondern in mehrere Subnetze unterteilt.";
​
                }
                else if (Convert.ToInt32(cidr) >= 8 & Convert.ToInt32(cidr) < 16)
                {
                    ipPräfix = ersteOktet + ".";
                    ipSuffixStart = ".0.0";
                    ipSuffixEnd = ".255.255";
​
                    gz = Convert.ToInt32(zweiteOktet) / Convert.ToInt32(sw);
                    nid = gz * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);
​
                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString() + ipSuffixStart, ipPräfix + bc.ToString() + ipSuffixEnd, "255." + sm.ToString() + ipSuffixStart, ((256 * 256 * sw) - 2).ToString());
​
                }
                else if (Convert.ToInt32(cidr) >= 16 & Convert.ToInt32(cidr) < 24)
                {
                    ipPräfix = ersteOktet + "." + zweiteOktet + ".";
                    ipSuffixStart = ".0";
                    ipSuffixEnd = ".255";
​
                    gz = Convert.ToInt32(dritteOktet) / Convert.ToInt32(sw);
                    nid = gz * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);
​
                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString() + ipSuffixStart, ipPräfix + bc.ToString() + ipSuffixEnd, "255.255." + sm.ToString() + ipSuffixStart, ((256 * sw) - 2).ToString());
​
                }
                else if (Convert.ToInt32(cidr) >= 24 & Convert.ToInt32(cidr) < 32)
                {
                    ipPräfix = ersteOktet + "." + zweiteOktet + "." + dritteOktet + ".";
​
                    gz = Convert.ToInt32(vierteOktet) / Convert.ToInt32(sw);
                    nid = Convert.ToInt32(gz) * Convert.ToInt32(sw);
                    bc = nid + (Convert.ToInt32(sw) - 1);
                    sm = 256 - Convert.ToInt32(sw);
​
                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString(), ipPräfix + bc.ToString(), "255.255.255." + sm.ToString(), (sw - 2).ToString());
​
                    if (cidr == "31") netzwerkInfo += netzwerkInfo += "\n \n/31-Netze enthalten keine nutzbaren Host-Adressen, \nwährend /32 kein Subnetz, sondern immer einen einzelnen Host adressiert.\nHierbei gibt es auch Ausnahmen. \nSo wurde im RFC 3021 vorgeschlagen, \ndass /31-Netze genutzt werden, um Point-to-point-Verbindungen zu etablieren. \nDies wurde unter anderem von der Firma Cisco implementiert. Des Weiteren ist es \nunter bestimmten Umständen möglich, \ndie Netz- und Broadcastadresse für Hosts zu verwenden.";
​
                }
                else if (Convert.ToInt32(cidr) == 32)
                {
                    ipPräfix = ersteOktet + "." + zweiteOktet + "." + dritteOktet + ".";
​
                    gz = Convert.ToInt32(vierteOktet) / Convert.ToInt32(sw);
                    nid = Convert.ToInt32(vierteOktet);
                    bc = 255;
                    sm = 255;
​
                    netzwerkInfo = String.Format(" NETZWERK ID: {0} \n BROADCAST: {1} \n SUBNETMASK: {2} \n ANZAHL DER RECHNERS: {3}", ipPräfix + nid.ToString(), "KEIN", "255.255.255." + sm.ToString(), (2 - 2).ToString());
​
                    netzwerkInfo += "\n \n/31-Netze enthalten keine nutzbaren Host-Adressen, \nwährend /32 kein Subnetz, sondern immer einen einzelnen Host adressiert.\nHierbei gibt es auch Ausnahmen. \nSo wurde im RFC 3021 vorgeschlagen, \ndass /31-Netze genutzt werden, um Point-to-point-Verbindungen zu etablieren. \nDies wurde unter anderem von der Firma Cisco implementiert. Des Weiteren ist es \nunter bestimmten Umständen möglich, \ndie Netz- und Broadcastadresse für Hosts zu verwenden.";
​
                }
​
                else Console.WriteLine("Unerwartete Wert");
​
                foreach (char y in (netzwerkInfo).ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }
​
                Console.WriteLine();
​
                //Console.WriteLine(netzwerkInfo);
​
                Console.WriteLine();
​
                foreach (char y in ("Um Programm zu beenden, geben Sie 'exit' ein: ").ToArray())
                {
                    Console.Write(y);
                    Console.ForegroundColor = (ConsoleColor)consoleColors.GetValue(r.Next(consoleColors.Length));
                    var task = Task.Run(async delegate
                    {
                        await Task.Delay(44);
                        return 42;
                    });
                    task.Wait();
                }
​
                //Console.Write();
​
            } while (Console.ReadLine() != "exit");
​
        }
    }
}
​

Compilation error (line 1, col 1): A namespace cannot directly contain members such as fields or methods

Last Run:	3:00:22 pm
Compile:	0s
Execute:	0.258s
Memory:	0b
CPU:	0s

View IL Code