嘿，这个需求我刚好在项目里实践过，给你拆解成两个核心部分来实现，都是ASP.NET环境下非常实用的方案：

绝大多数站点都是通过User-Agent（UA）字符串来判断请求是否来自移动设备的，所以第一步就是给你的出站请求设置一个真实的移动设备UA。

你可以直接用市面上主流移动设备的UA，比如：

• 苹果iPhone 14的UA：Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1
• 谷歌Pixel 7的UA：Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Mobile Safari/537.36

在ASP.NET里，用HttpClient实现的代码示例如下：

// 初始化HttpClient，并设置移动设备UA
var httpClient = new HttpClient();
// 替换成你需要的移动UA
httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1");

// 发送请求
var response = await httpClient.GetAsync("https://目标站点地址");

如果需要更灵活的UA切换，也可以在每次请求时单独设置，而不是全局默认：

var request = new HttpRequestMessage(HttpMethod.Get, "https://目标站点地址");
request.Headers.UserAgent.ParseAdd("你的移动UA字符串");
var response = await httpClient.SendAsync(request);

仅仅设置UA还不够，要模拟真实的移动网络体验，需要从两个维度优化：

2.1 添加移动网络标识请求头 #

部分站点会通过自定义请求头来识别网络类型，你可以添加这些头来告知目标站点当前是3G/4G网络，常用的头包括：

• X-Network-Type: 3G 或 X-Network-Type: 4G
• X-Requested-With: XMLHttpRequest（部分移动端网页会检查这个）

代码示例：

request.Headers.Add("X-Network-Type", "4G");
request.Headers.Add("X-Requested-With", "XMLHttpRequest");

2.2 模拟移动网络的延迟与带宽限制 #

真实的移动网络不会像宽带那样快，3G的平均下载速度大概在1-3Mbps，4G在10-50Mbps，同时会有100-300ms左右的延迟。我们可以通过自定义HttpMessageHandler来模拟这个效果：

public class MobileNetworkSimulatorHandler : DelegatingHandler
{
    // 模拟的网络延迟（毫秒），3G设200-300，4G设100-200
    private readonly int _networkDelayMs;
    // 模拟的带宽（字节/秒），3G约125KB/s（1Mbps），4G约1.25MB/s（10Mbps）
    private readonly int _maxBytesPerSecond;

    public MobileNetworkSimulatorHandler(int networkDelayMs, int maxBytesPerSecond)
    {
        _networkDelayMs = networkDelayMs;
        _maxBytesPerSecond = maxBytesPerSecond;
        InnerHandler = new HttpClientHandler();
    }

    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        // 先模拟网络延迟
        await Task.Delay(_networkDelayMs, cancellationToken);

        // 发送请求并获取响应
        var response = await base.SendAsync(request, cancellationToken);

        // 如果响应有内容，模拟带宽限制
        if (response.Content != null)
        {
            var originalContent = await response.Content.ReadAsStreamAsync(cancellationToken);
            var throttledStream = new ThrottledStream(originalContent, _maxBytesPerSecond);
            response.Content = new StreamContent(throttledStream);
        }

        return response;
    }
}

// 辅助类：实现流的限速
public class ThrottledStream : Stream
{
    private readonly Stream _innerStream;
    private readonly int _maxBytesPerSecond;
    private readonly Stopwatch _stopwatch = Stopwatch.StartNew();
    private long _bytesRead = 0;

    public ThrottledStream(Stream innerStream, int maxBytesPerSecond)
    {
        _innerStream = innerStream;
        _maxBytesPerSecond = maxBytesPerSecond;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        Throttle();
        var bytesRead = _innerStream.Read(buffer, offset, count);
        _bytesRead += bytesRead;
        return bytesRead;
    }

    public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
    {
        await ThrottleAsync(cancellationToken);
        var bytesRead = await _innerStream.ReadAsync(buffer, offset, count, cancellationToken);
        _bytesRead += bytesRead;
        return bytesRead;
    }

    private void Throttle()
    {
        var elapsedSeconds = _stopwatch.Elapsed.TotalSeconds;
        var expectedBytes = elapsedSeconds * _maxBytesPerSecond;
        if (_bytesRead > expectedBytes)
        {
            var delaySeconds = (_bytesRead - expectedBytes) / _maxBytesPerSecond;
            Thread.Sleep(TimeSpan.FromSeconds(delaySeconds));
        }
    }

    private async Task ThrottleAsync(CancellationToken cancellationToken)
    {
        var elapsedSeconds = _stopwatch.Elapsed.TotalSeconds;
        var expectedBytes = elapsedSeconds * _maxBytesPerSecond;
        if (_bytesRead > expectedBytes)
        {
            var delaySeconds = (_bytesRead - expectedBytes) / _maxBytesPerSecond;
            await Task.Delay(TimeSpan.FromSeconds(delaySeconds), cancellationToken);
        }
    }

    // 实现Stream的其他抽象方法，直接委托给_innerStream
    public override bool CanRead => _innerStream.CanRead;
    public override bool CanSeek => _innerStream.CanSeek;
    public override bool CanWrite => _innerStream.CanWrite;
    public override long Length => _innerStream.Length;
    public override long Position { get => _innerStream.Position; set => _innerStream.Position = value; }
    public override void Flush() => _innerStream.Flush();
    public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
    public override void SetLength(long value) => _innerStream.SetLength(value);
    public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
}

然后使用这个Handler来创建HttpClient：

// 模拟4G网络：延迟150ms，带宽1.25MB/s（10Mbps）
var mobileHandler = new MobileNetworkSimulatorHandler(150, 1250000);
var httpClient = new HttpClient(mobileHandler);
// 别忘了设置移动UA
httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("你的移动UA字符串");

// 发送请求，此时就会模拟4G的网络速度和延迟
var response = await httpClient.GetAsync("https://目标站点地址");

有些站点可能还会检查Accept头或者Referer头，你可以额外添加移动端常用的Accept值，比如：

httpClient.DefaultRequestHeaders.Accept.ParseAdd("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");

这样组合下来，你的请求就会非常接近真实的移动设备在3G/4G网络下的请求了。

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