Question

我正在尝试编写扫描环绕WiFi网络的程序，并将信息转储到包含SSID和加密类型的数组中。然后将SSID动态数组与试图将SSID匹配在一起然后输出结果的静态数组进行比较。

我在创建使用正则表达式时只使用SSID和加密的动态数组时遇到了麻烦。网络转储的输出如下所示：

Interface name : Wireless Network Connection 
There are 8 networks currently visible. 

SSID 1 : TheChinaClub-5G
    Network type            : Infrastructure
    Authentication          : WPA2-Personal
    Encryption              : CCMP

我尝试使用SSID作为密钥，使用以下数字作为通配符（但不知道语法）并在冒号后删除空格后获取数据。截至目前，除了网络转储之外没有任何作用。正则表达式似乎没有找到任何东西。我一直在使用this post作为正则表达式的模型。

这是我到目前为止的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;

namespace Rainbownetworks
{
    public struct Networkarr
    {
        public string x, y;

        public Networkarr(string SSID, string Encryption)
        {
            x = SSID;
            y = Encryption;
        }
    }

     class Program
    {

        static void Main(string[] args)
        {
            string[] StaticSSIDarr = { "network1", "network2", "network3" };
            string[] Networkarr = { };


            Process p = new Process();
            p.StartInfo.FileName = "netsh.exe";
            p.StartInfo.Arguments = "wlan show networks";
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.RedirectStandardOutput = true;
            p.Start();
            string results = p.StandardOutput.ReadToEnd();

            string[] SSIDs = { "SSID *"};

            FindSSIDs(SSIDs, results);

            Console.WriteLine(results);
            Console.ReadLine();




        }

        private static void FindSSIDs(IEnumerable<string> keywords, string source)
        {
            var found = new Dictionary<string, string>(10);
            var keys = string.Join("|", keywords.ToArray());
            var matches = Regex.Matches(source, @"(?<key>" + keys + "):",
                                  RegexOptions.IgnoreCase);

            foreach (Match m in matches)
            {
                var key = m.Groups["key"].ToString();
                var start = m.Index + m.Length;
                var nx = m.NextMatch();
                var end = (nx.Success ? nx.Index : source.Length);
                found.Add(key, source.Substring(start, end - start));
            }

            foreach (var n in found)
            {
                Networkarr newnetwork = new Networkarr(n.Key, n.Value);
                Console.WriteLine("Key={0}, Value={1}", n.Key, n.Value);
            }
        }
    }


}

Answer 1

试试这个

try {
    Regex regexObj = new Regex(@"(?<=SSID\s*\d+ :\s*)(?<value>\S+)");
    Match matchResults = regexObj.Match(subjectString);
    while (matchResults.Success) {
        for (int i = 1; i < matchResults.Groups.Count; i++) {
            Group groupObj = matchResults.Groups[i];
            if (groupObj.Success) {
                // matched text: groupObj.Value
                // match start: groupObj.Index
                // match length: groupObj.Length
            } 
        }
        matchResults = matchResults.NextMatch();
    } 
} catch (ArgumentException ex) {
    // Syntax error in the regular expression
}

<强>解释

@"
(?<=         # Assert that the regex below can be matched, with the match ending at this position (positive lookbehind)
   SSID         # Match the characters “SSID” literally
   \s           # Match a single character that is a “whitespace character” (spaces, tabs, and line breaks)
      *            # Between zero and unlimited times, as many times as possible, giving back as needed (greedy)
   \d           # Match a single digit 0..9
      +            # Between one and unlimited times, as many times as possible, giving back as needed (greedy)
   \ :          # Match the characters “ :” literally
   \s           # Match a single character that is a “whitespace character” (spaces, tabs, and line breaks)
      *            # Between zero and unlimited times, as many times as possible, giving back as needed (greedy)
)
(?<value>    # Match the regular expression below and capture its match into backreference with name “value”
   \S           # Match a single character that is a “non-whitespace character”
      +            # Between one and unlimited times, as many times as possible, giving back as needed (greedy)
)
"

希望这有帮助。

创建动态数组并与静态进行比较

1 个答案: