构建一个通用的c＃函数，允许函数作为参数传入

Question

I have a very ugly piece of code that is scattered throughout a project. The only difference in this piece of code is one line where a different method is called. The method that's called always returns a bool .

I want to refactor this and extract it into its own method and pass the 1 liner into this method (if possible) from my understanding I can use a Func<> to do this.

Here is what I am trying to do. I have tried to keep things as clear as possible

public async Task<bool> SomeMethod()
{
    //code removed for readability.

    //IsCustomerComplete will return a bool
    var process =  await RepeatableMasterPiece(1, 2, _myRepo.IsCustomerComplete(someParameterRequired));

    //do something with process result
    return process;
}

private async Task<bool> RepeatableMasterPiece(int param1, int param2, Func<Task<bool>> method)
{
    int retry = 0;
    bool soapComplete = false;
    string soapFault = "just a placeholder for example";
    bool blackListStatus = false;
    while (!soapComplete && retry <= 1)
    {
        try
        {
            if (soapFault != null)
            {
                //do some stuff with param1 & param2 here
            }
            if (!soapComplete)
            {
                return await method.Invoke();
            }
        }
        catch (FaultException ex)
        {
            soapFault = ex.Message;
            retry++;
            if (retry > 1)
            {
                throw ex;
            }
        }
    }
}

From the repo

public async Task<bool> IsCustomerComplete(int id)
{
    ...removed other code here
    return true;
}

Does this make sense, am I on the right track, from the examples I have found they only show Funcs<> passing in a string or int which makes things look a whole lot simpler.

Answer 1

If I understand your goal, you're very close. The biggest thing you're missing is the conversion of your method to a Func<> delegate. In your question, you included the argument parentheses. You don't need these if you're not invoking the method.

So, basically, this is what you probably want.

 var process =  await RepeatableMasterPiece(1, 2, _myRepo.IsCustomerComplete);

Answer 2

Here is an example based on your provided details.

public async Task SomeMethod() {
    //code in method.

    var _myRepo = new repo();
    var someParameterRequired = 1;
    var process = await RepeatableMasterPiece(1, 2, () => _myRepo.IsCustomerComplete(someParameterRequired));

    //do something with process result
}

private async Task<bool> RepeatableMasterPiece(int param1, int param2, Func<Task<bool>> method) {
    int retry = 0;
    bool soapComplete = false;
    string soapFault = "just a placeholder for example";
    bool blackListStatus = false;
    while (!soapComplete && retry <= 1) {
        try {
            if (soapFault != null) {
                //do some stuff with param1 & param2 here
            }
            if (!soapComplete && method != null) {
                return await method();
            }
        } catch (FaultException ex) {
            soapFault = ex.Message;
            retry++;
            if (retry > 1) {
                throw ex;
            }
        }
    }
    return false;
}

The assumption here is that all the target methods will be returning Task<bool>

If the target function does not require any parameters then you can do as mentioned in other answer and just provide the function itself without the parenthesis.

Answer 3

I would checkout Action<T> and Func<T, TResult> delegates.

• Use an Action<T> delegate when you wish to pass in an void anonymous method.

• Use an Func<TResult> delegate when you need to pass in a anonymous method with a return type.

MSDN has some good examples:

Func Delegates MSDN

Action Delegates MSDN

I have used actions and function many times over my career. They come in handy when adding features to tightly coupled code that cannot be refactored.

However, their correct usage should be used when writing loosely coupled code. There are many times where I wanted to give the implementer the option to provide their own functionality.