C#实现从Chrome获取指定标签页并修改页面内容

Got it, here's how you can pull this off without relying on WebDriver—we’ll use Chrome’s built-in Remote Debugging Protocol (RDP). It lets you talk directly to already running Chrome instances, hunt down specific tabs, parse their content, and tweak the page in real time.

Step 1: Enable Remote Debugging in Chrome #

First, you need to make sure Chrome is running with remote debugging turned on. If you already have Chrome open, you’ll need to restart it with this command-line flag:

• On Windows: Right-click your Chrome shortcut → Properties → Add --remote-debugging-port=9222 to the end of the "Target" field (e.g., chrome.exe --remote-debugging-port=9222)
• On macOS: Open Terminal and run open -a "Google Chrome" --args --remote-debugging-port=9222
• On Linux: Run google-chrome --remote-debugging-port=9222

This fires up Chrome with a debug server listening on port 9222.

Step 2: Fetch All Open Tabs and Locate Your Target #

Next, send an HTTP request to http://localhost:9222/json/list to get a list of every open tab and its details. Each entry includes a title field (we’ll use this to spot "Google Translate") and a webSocketDebuggerUrl—the endpoint we’ll use to interact with the tab.

Here’s a quick Python snippet to fetch and filter tabs:

import requests

# Grab list of all active tabs
tabs = requests.get("http://localhost:9222/json/list").json()

# Find the Google Translate tab
target_tab = next((tab for tab in tabs if "Google Translate" in tab["title"]), None)

if not target_tab:
    print("Target tab not found!")
else:
    print(f"Found target tab: {target_tab['title']}")
    ws_url = target_tab["webSocketDebuggerUrl"]

Step 3: Connect to the Tab via WebSocket and Interact #

Once you have the webSocketDebuggerUrl, use a WebSocket client to send commands to the tab. The RDP uses JSON-RPC messages to run actions like parsing DOM elements, evaluating JavaScript, or modifying page content.

Continuing with Python (you’ll need the websockets library—install it with pip install websockets):

import asyncio
import websockets
import json

async def interact_with_tab(ws_url):
    async with websockets.connect(ws_url) as ws:
        # Example 1: Grab current input text from Google Translate
        get_input_cmd = {
            "id": 1,
            "method": "Runtime.evaluate",
            "params": {
                "expression": 'document.querySelector("textarea[aria-label=\'Source text\']").value'
            }
        }
        await ws.send(json.dumps(get_input_cmd))
        response = await ws.recv()
        result = json.loads(response)
        print(f"Current input text: {result['result']['value']}")

        # Example 2: Update the input text on the page
        set_input_cmd = {
            "id": 2,
            "method": "Runtime.evaluate",
            "params": {
                "expression": 'document.querySelector("textarea[aria-label=\'Source text\']").value = "Hello from Chrome RDP!"'
            }
        }
        await ws.send(json.dumps(set_input_cmd))
        await ws.recv()  # Ignore the response if you don't need confirmation
        print("Successfully updated the input text!")

if target_tab:
    asyncio.run(interact_with_tab(ws_url))

Key Notes to Keep in Mind #

• Security Heads-Up: Remote debugging is for development use only—don’t leave it enabled on untrusted networks, since anyone with access to port 9222 can take control of your Chrome instance.
• DOM Selectors: Adjust the CSS selectors in the JavaScript expressions to match the elements you need on your target page (Google Translate’s selectors might change over time, so inspect the page to get the latest ones).
• Cross-Language Support: You can use any language with WebSocket support (Node.js, C#, etc.)—the RDP is language-agnostic as long as you can send JSON-RPC messages over WebSocket.

内容的提问来源于stack exchange，提问作者iTKerry