C # 명령으로 서비스에 MySQL 서버가 존재하도록 제어하려면 어떻게해야합니까?

사실상 아주 쉬워요

먼저 네임 스페이스 System.Diagnostics 코드에서 Process를 사용하여 창을 요청하여 기존 프로세스를 살펴 봅니다.

Process[] ProcessList = Process.GetProcesses()
 var started= ProcessList.Any(a => a.ProcessName.Equals("mysql", StringComparison.OrdinalIgnoreCase));

문제는 MySql이 사용하는 이름이 기본 이름인지 아니면 다른 이름인지에 대한 것입니다. 그렇다면 문제는 몇 개입니까?

아마도 하나의 옵션은 포트를 살펴보고 주어진 네트워크 포트에서 어떤 응용 프로그램이 수신 대기 중인지 확인하는 것입니다. 포트가 직면 한 설치에 대한 자세한 정보를 제공 할 수 있기 때문에 더욱 안정적입니다. .

그래서 내가하는 일은 모든 네트워크 카드의 모든 IP 핸들을 얻고 누가 누구와 대화하고 있는지를 보는 것입니다. 내 코드

var ip = new TCP().GetAllTcpConnections();

이것은 다음과 같은 서명을 가진 클래스를 반환합니다 :

public class TcpProcessRecord
{
    [DisplayName("Local Address")]
     public IPAddress LocalAddress { get; set; }
     [DisplayName("Local Port")]
     public ushort LocalPort { get; set; }
     [DisplayName("Remote Address")]
     public IPAddress RemoteAddress { get; set; }
     [DisplayName("Remote Port")]
     public ushort RemotePort { get; set; }
     [DisplayName("State")]
     public MibTcpState State { get; set; }
     [DisplayName("Process ID")]
     public int ProcessId { get; set; }
     [DisplayName("Process Name")]
     public string ProcessName { get; set; }
}

Process.GetProcesses ()에서 반환 된 프로세스 ID와 일치하는 경우 어떤 응용 프로그램이 네트워크에 연결되어 있고 어떤 포트에서 시도하고 있는지 알고 있습니다.

방화벽이 지정된 포트를 차단하여 서비스를 사용할 수 없는지 확인할 수도 있습니다.

마법은 내가 찾은 코드에 있으며, 원래 코드의 일부 메소드가 .net 4.7.X에서 더 이상 사용되지 않기 때문에 약간 업데이트해야했습니다

원본 코드를 어디서 찾았는지 모르겠지만 여기에 내 버전이 있습니다

public class TCP
    {
        #region TCP
        private const int AF_INET = 2;
        // The GetExtendedTcpTable function retrieves a table that contains a list of 
        // TCP endpoints available to the application. Decorating the function with 
        // DllImport attribute indicates that the attributed method is exposed by an 
        // unmanaged dynamic-link library 'iphlpapi.dll' as a static entry point. 
        [DllImport("iphlpapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern uint GetExtendedTcpTable(IntPtr pTcpTable, ref int pdwSize, bool bOrder, int ulAf, TcpTableClass tableClass, uint reserved = 0);
        /// <summary> 
        /// This function reads and parses the active TCP socket connections available 
        /// and stores them in a list. 
        /// </summary> 
        /// <returns> 
        /// It returns the current set of TCP socket connections which are active. 
        /// </returns> 
        /// <exception cref="OutOfMemoryException"> 
        /// This exception may be thrown by the function Marshal.AllocHGlobal when there 
        /// is insufficient memory to satisfy the request. 
        /// </exception> 
        public List<TcpProcessRecord> GetAllTcpConnections()
        {
            int bufferSize = 0;
            List<TcpProcessRecord> tcpTableRecords = new List<TcpProcessRecord>();
            // Getting the size of TCP table, that is returned in 'bufferSize' variable. 
            uint result = GetExtendedTcpTable(IntPtr.Zero, ref bufferSize, true, AF_INET, TcpTableClass.TCP_TABLE_OWNER_PID_ALL);
            // Allocating memory from the unmanaged memory of the process by using the 
            // specified number of bytes in 'bufferSize' variable. 
            IntPtr tcpTableRecordsPtr = Marshal.AllocHGlobal(bufferSize);
            try
            {
                // The size of the table returned in 'bufferSize' variable in previous 
                // call must be used in this subsequent call to 'GetExtendedTcpTable' 
                // function in order to successfully retrieve the table. 
                result = GetExtendedTcpTable(tcpTableRecordsPtr, ref bufferSize, true, AF_INET, TcpTableClass.TCP_TABLE_OWNER_PID_ALL);
                // Non-zero value represent the function 'GetExtendedTcpTable' failed, 
                // hence empty list is returned to the caller function. 
                if (result != 0)
                    return new List<TcpProcessRecord>();
                // Marshals data from an unmanaged block of memory to a newly allocated 
                // managed object 'tcpRecordsTable' of type 'MIB_TCPTABLE_OWNER_PID' 
                // to get number of entries of the specified TCP table structure. 
                MIB_TCPTABLE_OWNER_PID tcpRecordsTable = (MIB_TCPTABLE_OWNER_PID)Marshal.PtrToStructure(tcpTableRecordsPtr, typeof(MIB_TCPTABLE_OWNER_PID));
                IntPtr tableRowPtr = (IntPtr)((long)tcpTableRecordsPtr + Marshal.SizeOf(tcpRecordsTable.dwNumEntries));
                // Reading and parsing the TCP records one by one from the table and 
                // storing them in a list of 'TcpProcessRecord' structure type objects. 
                for (int row = 0; row < tcpRecordsTable.dwNumEntries; row++)
                {
                    MIB_TCPROW_OWNER_PID tcpRow = (MIB_TCPROW_OWNER_PID)Marshal.PtrToStructure(tableRowPtr, typeof(MIB_TCPROW_OWNER_PID));
                    tcpTableRecords.Add(new TcpProcessRecord(
                                          new IPAddress(tcpRow.localAddr),
                                          new IPAddress(tcpRow.remoteAddr),
                                          BitConverter.ToUInt16(new byte[2] {
                                              tcpRow.localPort[1],
                                              tcpRow.localPort[0] }, 0),
                                          BitConverter.ToUInt16(new byte[2] {
                                              tcpRow.remotePort[1],
                                              tcpRow.remotePort[0] }, 0),
                                          tcpRow.owningPid, tcpRow.state));
                    tableRowPtr = (IntPtr)((long)tableRowPtr + Marshal.SizeOf(tcpRow));
                }
            }
            finally
            {
                Marshal.FreeHGlobal(tcpTableRecordsPtr);
            }
            return tcpTableRecords != null ? tcpTableRecords.Distinct().ToList<TcpProcessRecord>() : new List<TcpProcessRecord>();
        }

        enum TcpTableClass
        {
            TCP_TABLE_BASIC_LISTENER,
            TCP_TABLE_BASIC_CONNECTIONS,
            TCP_TABLE_BASIC_ALL,
            TCP_TABLE_OWNER_PID_LISTENER,
            TCP_TABLE_OWNER_PID_CONNECTIONS,
            TCP_TABLE_OWNER_PID_ALL,
            TCP_TABLE_OWNER_MODULE_LISTENER,
            TCP_TABLE_OWNER_MODULE_CONNECTIONS,
            TCP_TABLE_OWNER_MODULE_ALL
        }
        // Enum for different possible states of TCP connection 
        public enum MibTcpState
        {
            CLOSED = 1,
            LISTENING = 2,
            SYN_SENT = 3,
            SYN_RCVD = 4,
            ESTABLISHED = 5,
            FIN_WAIT1 = 6,
            FIN_WAIT2 = 7,
            CLOSE_WAIT = 8,
            CLOSING = 9,
            LAST_ACK = 10,
            TIME_WAIT = 11,
            DELETE_TCB = 12,
            NONE = 0
        }
        [StructLayout(LayoutKind.Sequential)]
        public struct MIB_TCPROW_OWNER_PID
        {
            public MibTcpState state;
            public uint localAddr;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
            public byte[] localPort;
            public uint remoteAddr;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
            public byte[] remotePort;
            public int owningPid;
        }
        /// <summary> 
        /// The structure contains a table of process IDs (PIDs) and the IPv4 TCP links that  
        /// are context bound to these PIDs. 
        /// </summary> 
        [StructLayout(LayoutKind.Sequential)]
        public struct MIB_TCPTABLE_OWNER_PID
        {
            public uint dwNumEntries;
            // [MarshalAs(UnmanagedType.ByValArray, ArraySubType = UnmanagedType.Struct, SizeConst = 1)]
            [MarshalAs(UnmanagedType.ByValArray, ArraySubType = UnmanagedType.LPStruct, SizeConst = 1)]
            public MIB_TCPROW_OWNER_PID[] table;
        }
        /// <summary> 
        /// This class provides access an IPv4 TCP connection addresses and ports and its 
        /// associated Process IDs and names. 
        /// </summary> 
        [StructLayout(LayoutKind.Sequential)]
        public class TcpProcessRecord
        {
            [DisplayName("Local Address")]
            public IPAddress LocalAddress { get; set; }
            [DisplayName("Local Port")]
            public ushort LocalPort { get; set; }
            [DisplayName("Remote Address")]
            public IPAddress RemoteAddress { get; set; }
            [DisplayName("Remote Port")]
            public ushort RemotePort { get; set; }
            [DisplayName("State")]
            public MibTcpState State { get; set; }
            [DisplayName("Process ID")]
            public int ProcessId { get; set; }
            [DisplayName("Process Name")]
            public string ProcessName { get; set; }
            public TcpProcessRecord(IPAddress localIp, IPAddress remoteIp, ushort localPort,
                ushort remotePort, int pId, MibTcpState state)
            {
                LocalAddress = localIp;
                RemoteAddress = remoteIp;
                LocalPort = localPort;
                RemotePort = remotePort;
                State = state;
                ProcessId = pId;
                // Getting the process name associated with a process id. 
                if (Process.GetProcesses().Any(process => process.Id == pId))
                {
                    ProcessName = Process.GetProcessById(ProcessId).ProcessName;
                }
            }
        }
        /// <summary> 
        /// The structure contains an entry from the User Datagram Protocol (UDP) listener 
        /// table for IPv4 on the local computer. The entry also includes the process ID 
        /// (PID) that issued the call to the bind function for the UDP endpoint. 
        /// </summary> 
        [StructLayout(LayoutKind.Sequential)]
        public struct MIB_UDPROW_OWNER_PID
        {
            public uint localAddr;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
            public byte[] localPort;
            public int owningPid;
        }

        #endregion
    }

해피 코딩