Problem bei Erstellung eines NetzID Kalkulators

[Mendred]

Hallo, ich hoffe ich bin hier diesmal richtig

ch schreibe grad aus Langeweile einen NetzID Kalkulator.
Ich bin VB Anfänger und versuche mich grad an mehrdimensionalen Arrays.
Ich bin mit meinem Latein am Ende, ich weiss nicht genau, warum das Programm die Fehlerfunktion aufruft. Ich hab meinen Quellcode von dem Programm angehängt, ich hoffe mir kann jemand helfen.

Das Programm wandelt eingegebene Zahlen zuerst in Dualzahlen um und vergleicht diese dann, also IP mit Subnetmask, um daraus die NetzID zu erhalten. Die Zahlen werden also Bitweise UND verknüpft. Leider steckt da irgendwo der Fehler drin.
Also
IP: 192.168.1.35
Subnetmask: 255.255.255.0
NetzID: 192.168.1.0

Raus kommen aber Zahlen wie 0.0.128.0 und dann erfolgt der Aufruf des Fehlerfensters.
Ich bekomm die Meldung, dass das Programm versucht mehr Arrayfelder zu beschreiben, als vorhanden sind.
Ich habe die Rechnung aber in einem Konsolenprogramm getestet und da benutzt er nur 8 der gegebenen 8 Felder.
Wer das komplette Programm benötigt, einfach melden.

On Error GoTo ErrorFunction
        Dim var_ipbox1 As Integer = CInt(IP_Box1.Text)
        Dim var_ipbox2 As Integer = CInt(IP_Box2.Text)
        Dim var_ipbox3 As Integer = CInt(IP_Box3.Text)
        Dim var_ipbox4 As Integer = CInt(IP_Box4.Text)
        Dim var_subbox1 As Integer = CInt(Sub_Box1.Text)
        Dim var_subbox2 As Integer = CInt(Sub_Box2.Text)
        Dim var_subbox3 As Integer = CInt(Sub_Box3.Text)
        Dim var_subbox4 As Integer = CInt(Sub_Box4.Text)
        Dim var_binIP(4, 8) As Integer
        Dim var_binSub(4, 8) As Integer
        Dim var_binNetID(4, 8) As Integer
        Dim var_NetID(4) As Integer
        Dim var_puffer As Integer = 0
        Dim var_puffer2 As Single = 0
        Dim var_i As Integer = 1
        Dim var_h As Integer = 0

        For var_h = 1 To 4 Step +1
            For var_i = 1 To 8 Step +1
                var_binIP(var_h, var_i) = 0
                var_binSub(var_h, var_i) = 0
                var_binNetID(var_h, var_i) = 0
            Next
        Next

        If var_ipbox1 >= 256 Or var_ipbox2 >= 256 Or var_ipbox3 >= 256 Or var_ipbox4 >= 256 Then
            FehlerForm.Show()
        ElseIf var_subbox1 >= 256 Or var_subbox2 >= 256 Or var_subbox3 >= 256 Or var_subbox4 >= 256 Then
            FehlerForm.Show()
        Else

            'Umwandlung der IP von Dezimal in Dual
            For var_h = 1 To 4 Step +1
                If var_h = 1 Then
                    var_puffer2 = var_ipbox1
                ElseIf var_h = 2 Then
                    var_puffer2 = var_ipbox2
                ElseIf var_h = 3 Then
                    var_puffer2 = var_ipbox3
                ElseIf var_h = 4 Then
                    var_puffer2 = var_ipbox4
                End If
                Do
                    var_puffer = CInt((var_puffer2 / 2 - 0.5))
                    var_binIP(var_h, var_i) = CInt(var_puffer2 Mod 2)
                    var_puffer2 = var_puffer
                    var_i = var_i + 1
                Loop Until var_puffer = 0
            Next var_h

            'Umwandlung der Subnetmask von Dezimal in Dual
            For var_h = 1 To 4 Step +1
                If var_h = 1 Then
                    var_puffer2 = var_subbox1
                ElseIf var_h = 2 Then
                    var_puffer2 = var_subbox2
                ElseIf var_h = 3 Then
                    var_puffer2 = var_subbox3
                ElseIf var_h = 4 Then
                    var_puffer2 = var_subbox4
                End If
                Do
                    var_puffer = CInt((var_puffer2 / 2 - 0.5))
                    var_binSub(var_h, var_i) = CInt(var_puffer2 Mod 2)
                    var_puffer2 = var_puffer
                    var_i = var_i + 1
                Loop Until var_puffer = 0
            Next var_h

            'Vergleich der Dualzahlen
            For var_h = 1 To 4 Step +1
                For var_i = 8 To 1 Step -1
                    If var_binIP(var_h, var_i) = 1 And var_binSub(var_h, var_i) = 1 Then
                        var_binNetID(var_h, var_i) = 1
                    Else
                        var_binNetID(var_h, var_i) = 0
                    End If
                Next var_i
            Next var_h

            'Potenzierung der Zahlen
            For var_h = 1 To 4 Step +1
                For var_i = 7 To 0 Step -1
                    var_NetID(var_h) = CInt(var_NetID(var_h) + (var_binNetID(var_h, var_i) * (2 ^ var_i)))
                Next var_i
            Next var_h

            'Ausgabe der Zahlen
            IDBox1.Text = CStr(var_NetID(1))
            IDBox2.Text = CStr(var_NetID(2))
            IDBox3.Text = CStr(var_NetID(3))
            IDBox4.Text = CStr(var_NetID(4))
        End If
        'Bei einem Programmfehler öffnet das Programm das Fehlerfenster
ErrorFunction:
        FehlerForm.Show()
    End Sub

 

[Danielku15]

Eigentlich bietet das .net Framework ja Klassen welche solche Aufgaben übernehmen. Aber hier eine eigene Lösung

NetworkData (Kleiner Containertyp um die 4 Oktetten abzuspeichern)

        ''' <summary>
        ''' Ein Struct um die 4 Oktetten einer IPAdresse bzw. Subnetmask zu speichern.
        ''' </summary>
        Public Structure NetworkData
            #Region "Felder"
            
            #Region "Constanten"
            
            Private Const OCTET_OUT_OF_RANGE As String = "Der Wert für die Oktetten darf nur im Bereich von 0-255 liegen!"
            
            #End Region
            
            Private _iFirstOctet As Integer
            Private _iSecondOctet As Integer
            Private _iThirdOctet As Integer
            Private _iFourthOctet As Integer
            #End Region
            
            #Region "Eigenschaften"
            Public Property FirstOctet() As Integer
                Get
                    Return _iFirstOctet
                End Get
                Set
                    If value < 0 OrElse value > 255 Then
                        Throw New ArgumentOutOfRangeException("value", OCTET_OUT_OF_RANGE)
                    End If
                    _iFirstOctet = value
                End Set
            End Property
            
            Public Property SecondOctet() As Integer
                Get
                    Return _iSecondOctet
                End Get
                Set
                    If value < 0 OrElse value > 255 Then
                        Throw New ArgumentOutOfRangeException("value", OCTET_OUT_OF_RANGE)
                    End If
                    _iSecondOctet = value
                End Set
            End Property
            
            Public Property ThirdOctet() As Integer
                Get
                    Return _iThirdOctet
                End Get
                Set
                    If value < 0 OrElse value > 255 Then
                        Throw New ArgumentOutOfRangeException("value", OCTET_OUT_OF_RANGE)
                    End If
                    _iThirdOctet = value
                End Set
            End Property
            
            Public Property FourthOctet() As Integer
                Get
                    Return _iFourthOctet
                End Get
                Set
                    If value < 0 OrElse value > 255 Then
                        Throw New ArgumentOutOfRangeException("value", OCTET_OUT_OF_RANGE)
                    End If
                    _iFourthOctet = value
                End Set
            End Property
            #End Region
            
            #Region "Konstruktor"
            Public Sub New(ByVal iFirstOctet As Integer, ByVal iSecondOctet As Integer, ByVal iThirdOctet As Integer, ByVal iFourthOctet As Integer)
                ' Erste Initialisierung
                _iFirstOctet = 0
                _iSecondOctet = 0
                _iThirdOctet = 0
                _iFourthOctet = 0
                ' Festlegung der Richtigen werte.
                FirstOctet = iFirstOctet
                SecondOctet = iSecondOctet
                ThirdOctet = iThirdOctet
                FourthOctet = iFourthOctet
            End Sub
            #End Region
            
            #Region "Methoden"
            
            Public Overloads Overrides Function ToString() As String
                Return String.Format("{0}.{1}.{2}.{3}", FirstOctet, SecondOctet, ThirdOctet, FourthOctet)
            End Function
            
            #End Region
        End Structure

Methode zur Berechnung der NetzID:

        ''' <summary>
        ''' Berechnet anhand einer IPAdresse und einer Subnetmask die Zugehörige NetzID.
        ''' </summary>
        ''' <param name="oIpAdress">Die IPAdresse des gesuchten Netzes.</param>
        ''' <param name="oSubnetMask">Die Subnetmask mit welcher das Netz unterteilt wird.</param>
        ''' <returns>Die anhand der IPAdresse und Subnetmask resultierende NetzID </returns>
        Public Shared Function CalculateNetworkId(ByVal oIpAdress As NetworkData, ByVal oSubnetMask As NetworkData) As NetworkData
            Dim oNetworkID As New NetworkData()
            ' Die Oktetten Jeweils bitweises AND berechnen
            oNetworkID.FirstOctet = (oIpAdress.FirstOctet And oSubnetMask.FirstOctet)
            oNetworkID.SecondOctet = (oIpAdress.SecondOctet And oSubnetMask.SecondOctet)
            oNetworkID.ThirdOctet = (oIpAdress.ThirdOctet And oSubnetMask.ThirdOctet)
            oNetworkID.FourthOctet = (oIpAdress.FourthOctet And oSubnetMask.FourthOctet)
            Return oNetworkID
        End Function

Anwendung:

        Private Shared Sub Main(ByVal args As String())
            
            Dim oTestIP As New NetworkData(192, 168, 1, 75)
            Dim oSubnet As New NetworkData(255, 255, 255, 192)
            Dim oResult As NetworkData = CalculateNetworkId(oTestIP, oSubnet)
            
            Console.WriteLine(oResult.ToString())
            Console.ReadKey()
        End Sub

(Gibt 192.168.1.64 aus. Sprich das 2. Subnetz was auch stimmt).

Hintergrund:
Lange Rede kurzer Sinn: In VB.net kannst du 2 Integer simpel mit dem Befehl And (Var1 And Var2) bitweise addieren. In C# wäre es der Operator & (Var1 & Var2). Der Rest ist rein für das strukturelle Ablegen der Daten.