How can I pass several methods (with parameters) AS a parameter?

Question

Suppose I have the following WCF code:

  try
  {
       ServiceClient proxy = new ServiceClient();
       proxy.ClientCredentials.UserName.UserName = "user";
       proxy.ClientCredentials.UserName.Password = "password";
       proxy.GetData(2);
       if (proxy.State = CommunicationState.Opened)
       {
           proxy.GetData("data");
       }
       proxy.Close();
  }
  catch (FaultException ex)
  {
      // handle the exception      
  }

And since I notice that the try...catch and other logic is repetitive, not to mention that setting up a WCF call is expensive, I want to send many "methods and parameters" to this function.

In essence pass GetData(2) and GetData("data") as a method array, and have the results return either asynchronously or synchronously.

How would I accomplish this?

I suppose I could have two 'ref' objects to handle the results[] and a shared lock to the results[]. However I'm not sure how to pass "methods with parameters" as a parameter to another function.

Perhaps another way of looking at this might be an array of function pointers, to the same function with different params.

Can anyone nudge me into the right way of doing this?

More info:

I am asking this question so I can optimize this approach to handling WCF exceptions and retries but so I don't have to always open/close the client after each call.

Answer 1

Use delegates and pass them in a list.

The C# Func<T> delegate is used when a return value is needed.

List<Func<Data>> funcList = new List<Func<Data>>();
funcList.Add( () => GetData(2) );

// You can use any condition as you otherwise would to add to the list.
if (proxy.State = CommunicationState.Opened)
{
   funcList.Add( () => GetData("data") );
}

List<Data> ProcessFuncs(List<Func<Data>> funcDatas)
{
    List<Data> returnList = new List<Data>();
    foreach(var func in funcDatas)
    {
        returnList.Add(func());
    }
}

( as long as the return types are identical, this will work )

This is just an example of course; if your methods don't return anything, you can use the C# Action delegate, which just executes an action and doesn't return any value.

List<Action> actionList = new List<Action>();
actionList.Add( () => ProcessData("data")); // ProcessData is a void with no return type
actionList.Add( () => ProcessData(2));

public void ProcessActions(List<Action> actions)
{
    foreach(var action in actions)
    {
        action();
    }
}

In response to some comments:

This code compiles and is all equivalent:

class Program
{
    public static string GetData(string item) { return item; }
    public static string GetData(int item) { return item.ToString(); }

    static void Main(string[] args)
    {
        string someLocalVar = "what is it?";
        int someLocalValueType = 3;

        Func<string> test = () =>
        {
            return GetData(someLocalVar);
        };

        Func<string> test2 = () => GetData(someLocalValueType);
        someLocalValueType = 5;

        List<Func<string>> testList = new List<Func<string>>();

        testList.Add(() => GetData(someLocalVar));
        testList.Add(() => GetData(2));
        testList.Add(test);
        testList.Add(test2);

        someLocalVar = "something else";

        foreach(var func in testList)
        {
            Console.WriteLine(func());
        }

        Console.ReadKey();
    }
}

Result is:

Answer 2

Bellow is an example of how to make a collection of delegates and their arguments then invoke them later on without knowing the methods definition. As far as I know if you want to invoke methods with different definitions in a single general call you have to do something like this.

   List<Tuple<delegate, object[]>> delegates = new List<Tuple<delegate, object[]>>();

   delegates.Add(new Tuple<delegate, object[]>(new Func<Arg1Type, Arg2Type, ReturnType>(MyFunctionName), new object[] { arg1, arg2 });

   foreach (Tuple<delegate, object[]> d in delegates)
   {
        d.Item1.DynamicInvoke(d.Item2);
   }

Answer 3

I wouldn't use delegates here because then you are constrained by types and to solve that it becomes horrible and over-complicated. I would just have a callback that gives you free reign over the ServiceClient once it has been set up. I think this is a pattern that has a name but I don't know.

interface IProxyActionCallback
{
    void DoProxyStuff(ServiceClient proxy);
}

void MyMethod(IProxyActionCallback callback)
{
    try
    {
        ServiceClient proxy = new ServiceClient();
        proxy.ClientCredentials.UserName.UserName = "user";
        proxy.ClientCredentials.UserName.Password = "password";

        callback.DoProxyStuff(proxy);

        proxy.Close();
    }
    catch (FaultException ex)
    {
        // handle the exception      
    }
}

Then you call the method like:

MyMethod(new DoSpecificStuff());

Where DoSpecificStuff is a class that implements the interface and allows you to do specific calls with the proxy:

class DoSpecificStuff : IProxyActionCallback
{
    public void DoProxyStuff(ServiceClient proxy)
    {
        proxy.GetData(2);
        if (proxy.State = CommunicationState.Opened)
        {
            proxy.GetData("data");
        }
    }
}

So you'd have tons of classes that implement the interface, and they all "share" the same try-catch boiler-plate proxy stuff which is in one place.

Answer 4

You could use C# delegates:

A delegate is a type that represents references to methods with a particular parameter list and return type. When you instantiate a delegate, you can associate its instance with any method with a compatible signature and return type. You can invoke (or call) the method through the delegate instance. Delegates are used to pass methods as arguments to other methods. Event handlers are nothing more than methods that are invoked through delegates. You create a custom method, and a class such as a windows control can call your method when a certain event occurs. The following example shows a delegate declaration:

More on this: http://msdn.microsoft.com/en-us/library/ms173171.aspx

Answer 5

You can pass functions with parameters this way:

public void strategy<R, T1, T2>(Func<R, T1, T2> f);

public bool predicate(string a, string b);

strategy<bool, string, string>(predicate);

The first line declares the function strategy() accepting a function f; That function return the type R and takes two parameters of type T1 and T2.

The second line defines a function that returns a bool and accepts two string.

The third line invokes the strategy passing it the predicate as a parameter.

Answer 6

Not sure to understand what you're trying to achieve, but basically if your service exposes a GetData(int) method and a GetData(string) method as well as an async proxy, you should call both asynchronously using something like:

var getData = proxy.GetDataAsync(2);
var getData2 = proxy.GetDataAsync("data");

await Task.WhenAll(getData, getData2);

// Gets the result using getData.Result...etc.