public partial class CreateResult
{
    public string Errors {get;set;}
}

public interface ICreateService
{
    Task<CreateResult> CreateAsync();
}

public partial class UpdateResult
{
    public string Errors {get;set;}
}

public interface IUpdateService
{
    Task<UpdateResult> UpdateAsync();
}

public partial class DeleteResult
{
    public string Errors {get;set;}
}

public interface IDeleteService
{
    Task<DeleteResult> DeleteAsync();
}

public class Connector
{
    private readonly ICreateService _createService;
    private readonly IUpdateService _updateService;
    private readonly IDeleteService _deleteService;
    private readonly Policy _policy = ???;

    public Connector(ICreateService createService, IUpdateService updateService, IDeleteService deleteService)
    {
        _createService = createService;
        _updateService = updateService;
        _deleteService = deleteService;
    }

    public async Task<CreateResult> CreateAsync()
    {
        // sample policy: var policy = Policy.Handle<Exception>()
        //                                   .OrResult<CreateResult>(r => r.Errors.Contains("EXCEPTION"))
        //                                   .Retry();
        // Now I need to create such a policy for every call. How can I create a single policy or a factory method to enforce DRY principle?

        return _policy.ExecuteAsync(() => _createService.CreateAsync());
    }

    public async Task<UpdateAsync> UpdateAsync()
    {
        return _policy.ExecuteAsync(() => _updateService.UpdateAsync());
    }

    public async Task<DeleteResult> DeleteAsync()
    {
        return _policy.ExecuteAsync(() => _deleteService.DeleteAsync());
    }
}