using System;
using System.IO;
using System.Net.Http;
using System.Net;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string[] proxies = File.ReadAllLines("http.txt");
        string proxy = proxies[0];
        string[] proxyParts = proxy.Split(':');

        var httpClientHandler = new HttpClientHandler()
        {
            Proxy = new WebProxy(proxyParts[0], int.Parse(proxyParts[1])),
            UseProxy = true,
        };

        HttpClient client = new HttpClient(httpClientHandler);
        HttpResponseMessage response = await client.GetAsync("http://example.com");
        string content = await response.Content.ReadAsStringAsync();
        Console.WriteLine(content);
    }
}

package main

import (
    "bufio"
    "fmt"
    "net/http"
    "net/url"
    "os"
    "strings"
)

func main() {
    file, err := os.Open("http.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    scanner.Scan()
    proxyLine := scanner.Text()
    proxyURL, err := url.Parse("http://" + proxyLine)
    if err != nil {
        panic(err)
    }

    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}
    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

import java.io.BufferedReader
import java.io.File
import java.net.HttpURLConnection
import java.net.InetSocketAddress
import java.net.Proxy
import java.net.URL

fun main() {
    val proxies = File("http.txt").readLines()
    val proxyParts = proxies[0].split(":")

    val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress(proxyParts[0], proxyParts[1].toInt()))
    val url = URL("http://example.com")
    val connection = url.openConnection(proxy) as HttpURLConnection

    connection.inputStream.bufferedReader().use(BufferedReader::readText).let {
        println(it)
    }
}

import Foundation

if let proxyList = try? String(contentsOfFile: "http.txt") {
    let proxies = proxyList.components(separatedBy: "\n")
    let proxyParts = proxies[0].components(separatedBy: ":")

    let config = URLSessionConfiguration.default
    config.connectionProxyDictionary = [
        kCFNetworkProxiesHTTPEnable: true,
        kCFNetworkProxiesHTTPProxy: proxyParts[0],
        kCFNetworkProxiesHTTPPort: Int(proxyParts[1]) ?? 8080
    ] as [String : Any]

    let session = URLSession(configuration: config)
    let url = URL(string: "http://example.com")!

    let task = session.dataTask(with: url) { data, response, error in
        if let data = data, let responseString = String(data: data, encoding: .utf8) {
            print(responseString)
        }
    }
    task.resume()
}

import Alamofire

if let proxyList = try? String(contentsOfFile: "http.txt") {
    let proxies = proxyList.components(separatedBy: "\n")
    let proxyParts = proxies[0].components(separatedBy: ":")

    let sessionManager = Session.default
    sessionManager.sessionConfiguration.connectionProxyDictionary = [
        kCFNetworkProxiesHTTPEnable: true,
        kCFNetworkProxiesHTTPProxy: proxyParts[0],
        kCFNetworkProxiesHTTPPort: Int(proxyParts[1]) ?? 8080
    ]

    sessionManager.request("http://example.com").responseString { response in
        switch response.result {
        case .success(let value):
            print(value)
        case .failure(let error):
            print(error)
        }
    }
}

import requests

with open('http.txt') as file:
    proxies = file.readlines()

proxy = proxies[0].strip()
response = requests.get('http://example.com', proxies={'http': proxy})
print(response.text)

const axios = require('axios');
const fs = require('fs');

fs.readFile('http.txt', 'utf8', (err, data) => {
    if (err) throw err;
    const proxies = data.split('\n');
    const proxy = proxies[0];

    axios.get('http://example.com', {
        proxy: {
            host: proxy.split(':')[0],
            port: proxy.split(':')[1]
        }
    })
    .then(response => console.log(response.data))
    .catch(error => console.error(error));
});

proxy=$(head -n 1 http.txt)
curl -x $proxy http://example.com

<?php
$proxies = file('http.txt', FILE_IGNORE_NEW_LINES);
$proxy = $proxies[0];

$context = stream_context_create([
    'http' => [
        'proxy' => 'tcp://' . $proxy,
        'request_fulluri' => true,
    ],
]);

$response = file_get_contents('http://example.com', false, $context);
echo $response;
?>

require 'net/http'

proxies = File.readlines('http.txt')
proxy = proxies[0].strip.split(':')

uri = URI('http://example.com')
Net::HTTP.start(uri.host, uri.port, proxy[0], proxy[1].to_i) do |http|
  request = Net::HTTP::Get.new uri
  response = http.request request
  puts response.body
end

import java.io.*;
import java.net.*;

public class ProxyExample {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("http.txt"));
        String proxyLine = reader.readLine();
        reader.close();
        
        String[] proxyParts = proxyLine.split(":");
        String proxyHost = proxyParts[0];
        int proxyPort = Integer.parseInt(proxyParts[1]);

        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
        URL url = new URL("http://example.com");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);

        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String inputLine;
        StringBuilder content = new StringBuilder();
        while ((inputLine = in.readLine()) != null) {
            content.append(inputLine);
        }
        in.close();

        System.out.println(content.toString());
    }
}