how to not copy code ? generic and non generic implementation - to use same body

please tell me how should i rework this code so it is not so much copy/paste? is there any way to call generic as nongeneric? should i pass <object> to generic and be happy with that? what is best solution ?

i have for example

public interface IHttpService
{
 Task<T> Post<T>(string uri, HttpContent content, int timeOut = 100, CancellationToken token = default);
 Task Post(string uri, HttpContent content, int timeOut = 100, CancellationToken token = default);
 }

so they have almost same but diferent implementation

 public async Task Post(string uri, HttpContent content, int timeOut = 100, CancellationToken token = default)
{
    var request = new HttpRequestMessage(HttpMethod.Post, uri);
    request.Content = content;
    await sendRequest(request, timeOut, token);
}

public async Task<T> Post<T>(string uri, HttpContent content, int timeOut = 100, CancellationToken token = default)
{
    var request = new HttpRequestMessage(HttpMethod.Post, uri);
    request.Content = content;
    return await sendRequest<T>(request, timeOut, token);
}


private async Task sendRequest(HttpRequestMessage request, int timeOut = 100, CancellationToken token = default)
{
    try
    {
        using var requestCTS = new CancellationTokenSource(TimeSpan.FromSeconds(timeOut));
        using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(requestCTS.Token, token);
        using var response = await _httpClient.SendAsync(request, linkedCts.Token);

        if (!response.IsSuccessStatusCode)
        {              
                var error = await response.Content.ReadAsStringAsync(token);
                throw new Exception(error);             
        }     
}

private async Task<T> sendRequest<T>(HttpRequestMessage request, int timeOut = 100, CancellationToken token = default)
{
    try
    {
        using var requestCTS = new CancellationTokenSource(TimeSpan.FromSeconds(timeOut));
        using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(requestCTS.Token, token);      
        using var response = await _httpClient.SendAsync(request, linkedCts.Token);
        
        if (!response.IsSuccessStatusCode)
        {      
                var error = await response.Content.ReadAsStringAsync(token);
                throw new Exception(error);
            
        }
        return (await response.Content.ReadFromJsonAsync<T>())!;

}

update

private async Task<HttpContent> sendRequest(HttpRequestMessage request, int timeOut = 100, CancellationToken token = default)
{
    try
    {
        using var requestCTS = new CancellationTokenSource(TimeSpan.FromSeconds(timeOut));
        using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(requestCTS.Token, token);
        using var response = await _httpClient.SendAsync(request, linkedCts.Token);
     
        if (!response.IsSuccessStatusCode)
        {
             await response.Content.ReadAsStringAsync(token);
                throw new Exception(error);
            
        }

        return response.Content;

    }
    catch (AccessTokenNotAvailableException)
    {
        _navigationManager.NavigateToLogout(StaticStringHelper.LogoutPatch);
        return default(HttpContent)!;
    }
}

and when i use it like

 public async Task<T> Get<T>(string uri, int timeOut = 100, CancellationToken token = default)
{
    var request = new HttpRequestMessage(HttpMethod.Get, uri);        
    return  await (await sendRequest(request, timeOut, token)).ReadFromJsonAsync<T>(cancellationToken: token);

}

i get

 microsoft.AspNetCore. Components.WebAssembly.Rendering.WebAssemblyRenderer[100]
  Unhandled exception rendering component: Cannot access a disposed object.
  Object name: 'System.Net.Http.BrowserHttpContent'.
System. ObjectDisposedException: Cannot access a disposed object.
Object name: 'System.Net.Http.BrowserHttpContent'.
 at System.Net.Http.HttpContent.CheckDisposed()
 at System.Net.Http.HttpContent.ReadAsStreamAsync(CancellationToken cancellationToken)

There is no generic "void" in c#. In some cases you can just use a generic with something like a int or bool as a meaningless value. In other cases you just have to suck it up and keep two implementations.

In this particular case the only difference seem to be response.Content.ReadFromJsonAsync<T>(), so you should be able to refactor this to make all other code common. Since the content is disposed you need to use a delegate to inject the code that is different:

 public Task Post(string uri, HttpContent content, int timeOut = 100, CancellationToken token = default)
=> Post<int>(uri, content, c => Task.FromResult(0), timeOut , token);

public async Task<T> Post<T>(string uri, HttpContent content, int timeOut = 100, CancellationToken token = default)
=> Post(uri, content, ReadFromJson, timeOut , token)!;

private Task<T> ReadFromJson(HttpContent content) => content.ReadFromJsonAsync<T>();

private async Task<T> Post<T>(string uri, HttpContent content, Func<HttpContent, Task<T>> handleContent, int timeOut = 100, CancellationToken token = default)
{
    var request = new HttpRequestMessage(HttpMethod.Post, uri);
    request.Content = content;
        try
    {
        using var requestCTS = new CancellationTokenSource(TimeSpan.FromSeconds(timeOut));
        using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(requestCTS.Token, token);      
        using var response = await _httpClient.SendAsync(request, linkedCts.Token);
        
        if (!response.IsSuccessStatusCode)
        {      
                var error = await response.Content.ReadAsStringAsync(token);
                throw new Exception(error);
            
        }
        return await handleContent(response.Content);
}

c => Task.FromResult(0) is just something to make the generic types fit, the '0' value never used anywhere.