>

"displayname"및 "servicename"이 C # 명령으로 "MySql"이 아닌 경우 어떻게 MySQL 서버가 서비스에 존재하도록 제어 할 수 있습니까?

"ServiceController.GetServices ();"로 제어 할 수 있습니다. "displayname"및 "servicename"이 "MySql"인 경우 해당 이름을 변경하면 해당 mysql 서버가 서비스에 존재하는지 또는 내 컴퓨터에 설치되어 있는지 제어 할 수 없습니까?

C # 명령을 사용하여 컴퓨터에서 mysql 서버를 어떻게 제어 할 수 있습니까?

마이 코드

   private void Form1_Load(object sender, EventArgs e)
       {         
        bool sonuc = serviceExists("mysql");
        if(sonuc==true)
        {
            MessageBox.Show("MySQL Exists.");
        }
        else
        {
            MessageBox.Show("MySQL doesnt exist.");
        }
    }
    public bool serviceExists(string ServiceName)
    {
        return ServiceController.GetServices().Any(serviceController => serviceController.ServiceName.Equals(ServiceName));
    }


  • 답변 # 1

    사실상 아주 쉬워요

    먼저 네임 스페이스 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
        }
    
    

    해피 코딩

관련 자료

  • 이전 python - Application Load Balancer에서 실행되는 플라스크 소켓
  • 다음 sql - 열을 그룹화하는 Oracle 쿼리