doNet窗口程序(C#)实现修改IP地址
182
|
|
1
|
.net,C#

代码功能概述

  1. 网络适配器管理：
    • 加载物理网卡列表，过滤虚拟网卡。
    • 显示选中网卡的详细信息（IP、子网掩码、网关、DNS）。
  2. 输入验证：
    • 限制 IP 输入框只能输入数字。
    • 验证 IP、子网掩码、网关、DNS 的格式。
  3. 网络配置保存：
    • 使用 netsh 命令配置静态 IP 和 DNS。
    • 检测并解决 IP 冲突。
  4. 自动获取 IP/DNS：
    • 将网卡设置为自动获取 IP 和 DNS。
  5. 网卡状态管理：
    • 启用或禁用选中的网卡。
  6. 页面刷新：
    • 清空输入并重新加载适配器列表和默认值。

根据自身业务需要，10和34为默认输入的项，默认网关在ip地址输入后自动填入第三段的x

成果展示

源码

using AntdUI;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.DirectoryServices.AccountManagement;
using System.Drawing;
using System.Linq;
using System.Management;
using System.Net.NetworkInformation;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;
using Button = AntdUI.Button;

namespace AntdUIDemo.Views
{
    public partial class IPSettings : UserControl
    {
        private AntdUI.Window window; // 父窗口引用

        public IPSettings(AntdUI.Window _window)
        {
            window = _window;
            InitializeComponent();
            AttachValidationEvents();  // 绑定输入验证事件
            LoadNetworkAdapters();    // 加载网络适配器列表
            InitializeInputs();      // 初始化输入框默认值
        }

        /// <summary>
        /// 加载网络适配器列表
        /// </summary>
        private void LoadNetworkAdapters()
        {
            selectAdapter.Items.Clear(); // 清空下拉列表
            try
            {
                // 获取所有物理网卡（过滤回环和虚拟网卡）
                var physicalAdapters = NetworkInterface.GetAllNetworkInterfaces()
                    .Where(ni => ni.NetworkInterfaceType != NetworkInterfaceType.Loopback &&
                                 !IsVirtualAdapter(ni.Description)) // 过滤掉虚拟网卡
                    .ToList();

                // 将所有物理网卡添加到下拉列表
                foreach (var adapter in physicalAdapters)
                {
                    selectAdapter.Items.Add(new SelectItem(adapter.Name, adapter.Name));
                }

                // 绑定选中事件
                selectAdapter.SelectedValueChanged += SelectAdapter_SelectedValueChanged;

                // 默认选中活动的网卡
                var activeAdapter = physicalAdapters.FirstOrDefault(ni => ni.OperationalStatus == OperationalStatus.Up);
                if (activeAdapter != null)
                {
                    var item = selectAdapter.Items.Cast<SelectItem>()
                        .FirstOrDefault(i => i.Text.Equals(activeAdapter.Name, StringComparison.OrdinalIgnoreCase));
                    if (item != null)
                    {
                        selectAdapter.SelectedValue = item.Text;
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"获取适配器失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 检查是否为虚拟网卡
        /// </summary>
        private bool IsVirtualAdapter(string adapterName)
        {
            // 虚拟网卡的关键字列表
            string[] virtualKeywords = { "Virtual", "Hyper-V", "VPN", "VMware", "VirtualBox", "TAP", "Tunnel" };

            // 检查适配器名称是否包含虚拟网卡关键字
            return virtualKeywords.Any(keyword => adapterName.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0);
        }

        /// <summary>
        /// 当用户选择适配器时更新信息
        /// </summary>
        private void SelectAdapter_SelectedValueChanged(object sender, EventArgs e)
        {
            string selectedAdapter = selectAdapter.SelectedValue?.ToString();
            if (!string.IsNullOrEmpty(selectedAdapter))
            {
                UpdateAdapterInfo(selectedAdapter); // 更新网卡信息
            }
        }

        /// <summary>
        /// 更新选中的适配器信息
        /// </summary>
        private void UpdateAdapterInfo(string adapterName)
        {
            var adapter = NetworkInterface.GetAllNetworkInterfaces()
                .FirstOrDefault(ni => ni.Name.Contains(adapterName));

            if (adapter != null)
            {
                // 提取 IP、子网掩码、网关、DNS 信息
                var ipProperties = adapter.GetIPProperties();
                string ipAddress = "未分配";
                string subnetMask = "未分配";
                string gateway = "未分配";
                string dns = "未分配";

                // 获取 IPv4 地址和子网掩码
                var unicastAddress = ipProperties.UnicastAddresses
                    .FirstOrDefault(addr => addr.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
                if (unicastAddress != null)
                {
                    ipAddress = unicastAddress.Address.ToString();
                    subnetMask = unicastAddress.IPv4Mask.ToString();
                }

                // 获取默认网关
                var gatewayAddress = ipProperties.GatewayAddresses
                    .FirstOrDefault(addr => addr.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
                if (gatewayAddress != null)
                {
                    gateway = gatewayAddress.Address.ToString();
                }

                // 获取 DNS 地址
                var dnsAddress = ipProperties.DnsAddresses
                    .FirstOrDefault(addr => addr.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
                if (dnsAddress != null)
                {
                    dns = dnsAddress.ToString();
                }

                // 显示信息到 Label
                labelAdapterInfo.Text = $"描述: {adapter.Description}\n" +
                                       $"状态: {adapter.OperationalStatus}\n" +
                                       $"IP 地址: {ipAddress}\n" +
                                       $"子网掩码: {subnetMask}\n" +
                                       $"默认网关: {gateway}\n" +
                                       $"DNS: {dns}";
            }
            else
            {
                labelAdapterInfo.Text = "未找到网卡信息";
            }
        }

        /// <summary>
        /// 初始化输入框默认值
        /// </summary>
        private void InitializeInputs()
        {
            inputIP1.Text = "10";
            inputIP2.Text = "34";
            inputIP3.Text = "";
            inputIP4.Text = "";
            inputSubnet.Text = "255.255.255.0";
            inputGateway.Text = "10.34.x.254";
            inputDNS.Text = "10.0.14.14";
        }

        /// <summary>
        /// 绑定输入验证事件
        /// </summary>
        private void AttachValidationEvents()
        {
            // 绑定 IP 输入框的键盘验证（仅允许数字）
            inputIP1.KeyPress += InputIP_KeyPress;
            inputIP2.KeyPress += InputIP_KeyPress;
            inputIP3.KeyPress += InputIP_KeyPress;
            inputIP4.KeyPress += InputIP_KeyPress;

            // IP3 输入变化时更新网关
            inputIP3.TextChanged += (s, e) => UpdateGateway();
        }

        /// <summary>
        /// 限制 IP 输入框只能输入数字
        /// </summary>
        private void InputIP_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar))
                e.Handled = true;
        }

        /// <summary>
        /// 根据 IP3 输入更新网关
        /// </summary>
        private void UpdateGateway()
        {
            string x = inputIP3.Text.Trim();
            inputGateway.Text = $"10.34.{(string.IsNullOrEmpty(x) ? "x" : x)}.254";
        }

        /// <summary>
        /// 验证所有输入框
        /// </summary>
        private bool ValidateInputs()
        {
            bool valid = true;
            ValidateInput(inputIP1, ref valid);
            ValidateInput(inputIP2, ref valid);
            ValidateInput(inputIP3, ref valid);
            ValidateInput(inputIP4, ref valid);
            ValidateInput(inputSubnet, ref valid, IsValidSubnet);
            ValidateInput(inputGateway, ref valid, IsValidIP);
            ValidateInput(inputDNS, ref valid, IsValidIP);
            return valid;
        }

        /// <summary>
        /// 验证单个输入框
        /// </summary>
        private void ValidateInput(Input input, ref bool valid, Func<string, bool> validator = null)
        {
            bool isValid = validator == null ? IsValidIPSegment(input.Text) : validator(input.Text);
            input.BorderColor = isValid ? Color.Black : Color.Red;
            if (!isValid) valid = false;
        }

        /// <summary>
        /// 验证 IP 段是否为 0-255
        /// </summary>
        private bool IsValidIPSegment(string segment)
        {
            return int.TryParse(segment, out int num) && num >= 0 && num <= 255;
        }

        /// <summary>
        /// 验证完整 IP 地址格式
        /// </summary>
        private bool IsValidIP(string ip)
        {
            return Regex.IsMatch(ip, @"^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$");
        }

        /// <summary>
        /// 验证子网掩码是否合法
        /// </summary>
        private bool IsValidSubnet(string subnet)
        {
            return IsValidIP(subnet) && subnet.Split('.').All(s => s == "0" || s == "128" || s == "192" ||
                s == "224" || s == "240" || s == "248" || s == "252" || s == "254" || s == "255");
        }

        /// <summary>
        /// 执行 netsh 命令
        /// </summary>
        private void ExecuteNetshCommand(string arguments)
        {
            try
            {
                ProcessStartInfo psi = new ProcessStartInfo("netsh", arguments)
                {
                    Verb = "runas", // 请求管理员权限
                    UseShellExecute = true,
                    CreateNoWindow = true,
                    WindowStyle = ProcessWindowStyle.Hidden
                };
                Process.Start(psi)?.WaitForExit();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"执行命令失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 保存网络配置
        /// </summary>
        private async void btnSave_Click(object sender, EventArgs e)
        {
            if (!ValidateInputs())
            {
                MessageBox.Show("输入无效，请检查红色标记的字段。");
                return;
            }

            string adapterName = selectAdapter.SelectedValue?.ToString();
            if (string.IsNullOrEmpty(adapterName))
            {
                MessageBox.Show("请选择一个网络适配器。");
                return;
            }

            string ip = $"{inputIP1.Text}.{inputIP2.Text}.{inputIP3.Text}.{inputIP4.Text}";
            string subnet = inputSubnet.Text;
            string gateway = inputGateway.Text;
            string dns = inputDNS.Text;

            // 检查 IP 冲突
            var conflictingAdapter = GetConflictingAdapter(ip, subnet, gateway);
            if (conflictingAdapter != null)
            {
                await ResolveConflict(conflictingAdapter); // 解决冲突
                MessageBox.Show($"检测到 IP 冲突，已将冲突网卡 {conflictingAdapter.Name} 设置为 DHCP 并禁用。");
            }

            // 禁用按钮，防止重复点击
            btnSave.Enabled = false;

            try
            {
                // 异步执行 netsh 命令
                await Task.Run(() =>
                {
                    ExecuteNetshCommand($"interface ip set address name=\"{adapterName}\" static {ip} {subnet} {gateway} 1");
                    ExecuteNetshCommand($"interface ip set dns name=\"{adapterName}\" static {dns}");
                });

                MessageBox.Show("网络配置已更新！");
                UpdateAdapterInfo(adapterName); // 刷新显示信息
            }
            catch (Exception ex)
            {
                MessageBox.Show($"执行命令失败: {ex.Message}");
            }
            finally
            {
                btnSave.Enabled = true; // 重新启用按钮
            }
        }

        /// <summary>
        /// 获取冲突的网卡
        /// </summary>
        private NetworkInterface GetConflictingAdapter(string ip, string subnet, string gateway)
        {
            foreach (var adapter in NetworkInterface.GetAllNetworkInterfaces())
            {
                var ipProperties = adapter.GetIPProperties();

                // 检查 IP 地址和子网掩码
                foreach (var unicastAddress in ipProperties.UnicastAddresses)
                {
                    if (unicastAddress.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                    {
                        string existingIp = unicastAddress.Address.ToString();
                        string existingSubnet = unicastAddress.IPv4Mask?.ToString();

                        if (existingIp == ip && existingSubnet == subnet)
                        {
                            return adapter; // 返回冲突的网卡
                        }
                    }
                }

                // 检查网关
                foreach (var gatewayAddress in ipProperties.GatewayAddresses)
                {
                    if (gatewayAddress.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                    {
                        string existingGateway = gatewayAddress.Address.ToString();

                        if (existingGateway == gateway)
                        {
                            return adapter; // 返回冲突的网卡
                        }
                    }
                }
            }
            return null; // 无冲突
        }

        /// <summary>
        /// 解决冲突：将冲突网卡设置为 DHCP 并禁用
        /// </summary>
        private async Task ResolveConflict(NetworkInterface conflictingAdapter)
        {
            try
            {
                await Task.Run(() =>
                {
                    ExecuteNetshCommand($"interface ip set address name=\"{conflictingAdapter.Name}\" source=dhcp");
                    ExecuteNetshCommand($"interface ip set dns name=\"{conflictingAdapter.Name}\" source=dhcp");
                });
                DisableAdapter(conflictingAdapter.Id); // 禁用网卡
            }
            catch (Exception ex)
            {
                throw new Exception($"解决冲突失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 禁用网卡
        /// </summary>
        private void DisableAdapter(string interfaceId)
        {
            try
            {
                ManagementObjectSearcher searcher = new ManagementObjectSearcher(
                    $"SELECT * FROM Win32_NetworkAdapter WHERE GUID = '{interfaceId}'");

                foreach (ManagementObject adapter in searcher.Get())
                {
                    adapter.InvokeMethod("Disable", null);
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"禁用网卡失败: {ex.Message}");
            }
        }


        /// <summary>
        /// 设置为自动获取 IP 和 DNS
        /// </summary>
        private async void btnSetAuto_Click(object sender, EventArgs e)
        {
            string adapterName = selectAdapter.SelectedValue?.ToString();
            if (string.IsNullOrEmpty(adapterName))
            {
                MessageBox.Show("请选择一个网络适配器。");
                return;
            }

            btnSetAuto.Enabled = false; // 禁用按钮

            try
            {
                await Task.Run(() =>
                {
                    ExecuteNetshCommand($"interface ip set address name=\"{adapterName}\" source=dhcp");
                    ExecuteNetshCommand($"interface ip set dns name=\"{adapterName}\" source=dhcp");
                });

                MessageBox.Show("已设置为自动获取 IP 和 DNS！");
                UpdateAdapterInfo(adapterName); // 刷新显示信息
            }
            catch (Exception ex)
            {
                MessageBox.Show($"执行命令失败: {ex.Message}");
            }
            finally
            {
                btnSetAuto.Enabled = true; // 重新启用按钮
            }
        }

        /// <summary>
        /// 切换网卡启用/禁用状态
        /// </summary>
        private void btnToggleAdapter_Click(object sender, EventArgs e)
        {
            string adapterName = selectAdapter.SelectedValue?.ToString();
            if (string.IsNullOrEmpty(adapterName))
            {
                MessageBox.Show("请选择一个网络适配器。");
                return;
            }

            try
            {
                var adapter = GetNetworkAdapterByName(adapterName);
                if (adapter == null)
                {
                    MessageBox.Show("未找到选中的网络适配器。");
                    return;
                }

                bool isEnabled = IsAdapterEnabled(adapter);
                if (isEnabled)
                {
                    string interfaceId = adapter["GUID"].ToString();
                    DisableAdapter(interfaceId);
                    MessageBox.Show($"已禁用网卡: {adapterName}");
                }
                else
                {
                    EnableAdapter(adapter);
                    MessageBox.Show($"已启用网卡: {adapterName}");
                }

                UpdateAdapterInfo(adapterName); // 刷新显示信息
            }
            catch (Exception ex)
            {
                MessageBox.Show($"切换网卡状态失败: {ex.Message}");
            }
        }

        /// <summary>
        /// 通过名称获取网卡
        /// </summary>
        private ManagementObject GetNetworkAdapterByName(string adapterName)
        {
            ManagementObjectSearcher searcher = new ManagementObjectSearcher(
                $"SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionID = '{adapterName}'");
            return searcher.Get().OfType<ManagementObject>().FirstOrDefault();
        }

        /// <summary>
        /// 检查网卡是否启用
        /// </summary>
        private bool IsAdapterEnabled(ManagementObject adapter)
        {
            return (bool)adapter["NetEnabled"];
        }

        /// <summary>
        /// 启用网卡
        /// </summary>
        private void EnableAdapter(ManagementObject adapter)
        {
            try
            {
                adapter.InvokeMethod("Enable", null);
            }
            catch (Exception ex)
            {
                throw new Exception($"启用网卡失败: {ex.Message}");
            }
        }
        /// <summary>
        /// 刷新页面
        /// </summary>
        private void refreshButton_Click(object sender, EventArgs e)
        {
            selectAdapter.Clear();
            inputIP1.Clear();
            inputIP2.Clear();
            inputIP3.Clear();
            inputIP4.Clear();
            inputSubnet.Clear();
            inputGateway.Clear();
            inputDNS.Clear();
            labelAdapterInfo.Text = "";
            LoadData(); // 重新加载数据
        }

        /// <summary>
        /// 重新加载数据
        /// </summary>
        private void LoadData()
        {
            LoadNetworkAdapters(); // 重新加载适配器
            InitializeInputs();     // 重置输入框默认值
        }
    }
}
.netC#

评论

  1. obaby
    Macintosh Chrome
    1 月前
    2025-3-24 15:34:37

    好久不见.net 的代码了

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																				
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇