We Keep Coding

Passing parameter to a method and assigning to type Func<bool>

I currently have a method like that resembles this
public static bool test(string str);
I would like to assign this method to this type
Func<bool> callback
I am trying to do this (which is incorrect)
callback = test("Str");
The above is incorrect as C# things i am calling a method. How can I tell it to call that method with the parameter Str ? in C++ we can do this
std::function<...,..,"str">
How do we do something similar in C# ?

If your goal is to invoke the callback always using the same string argument (and not a different argument each time), you can declare it like:
Func<bool> callback = () => test("Str");
var result = callback();
But if you are intending to pass a different string value each time, then you need a Func<string, bool>:
Func<string, bool> callback = s => test(s);
var result = callback("Str");

you should declare the function as:
Func<string, bool> callback
to indicate the method it references consumes a string and returns a bool.
then at a later point you can do:
callback = s => test(s);
or inline:
Func<string, bool> callback = s => test(s);

Let me see if I know what you're getting at. In C++ we have 'function pointers' and they are declared with a particular signature. To make the equivalent of that in C# use the delegate keyword.
Here's a quick functional code example:
class DelegateExample
{
// A delegate is a prototype for a function signature.
// Similar to a function pointer in C++.
delegate bool MyDelegate(string[] strings);
// A method that has that signature.
bool ListStrings(string[] strings)
{
foreach (var item in strings)
{
Console.WriteLine(item);
}
return strings.Length > 0; // ... for example
}
// Different method, same signature.
bool Join(string[] strings)
{
Console.WriteLine(string.Join(", ", strings));
return strings.Length > 0; // ... for example
}
public void TryIt()
{
string[] testData = { "Apple", "Orange", "Grape" };
// Think of this as a list of function pointers...
List<MyDelegate> functions = new List<MyDelegate>();
functions.Add(ListStrings); // This one points to the ListStrings method
functions.Add(Join); // This one points to the Join method
foreach (var function in functions)
{
bool returnVal = function(testData);
Console.WriteLine("The method returned " + returnVal + Environment.NewLine);
}
}
}
You can run the sample in a console app like so:
class Program
{
static void Main(string[] args)
{
new DelegateExample().TryIt();
Console.ReadKey();
}
}
Which gives this output:
Apple
Orange
Grape
The method returned True
Apple, Orange, Grape
The method returned True
Hope this is helpful!

Alter the parameters of an instance of an Action object

Say I have the following code:
void Main()
{
SeveralCalls(() => CallWithParams("test"),
() => CallWithParams("AnotherTest"));
}
public void SeveralCalls(params Action[] methodsToCall)
{
foreach (var methodToCall in methodsToCall)
{
methodToCall();
}
}
public void CallWithParams(string someValue, string otherValue = null)
{
Console.WriteLine("SomeValue: " + someValue);
Console.WriteLine("OtherValue: " + otherValue);
}
Is it possible to supply a value for the parameter otherValue for the calls to CallWithParams by only modifying the SeveralCalls method?
I want to inject a value into the calls if it comes via the SeveralCalls method.
As a bit of background, I am working on code to call tabled paramed stored procedures (as a way to integrate my WCF Service into legacy code). The call normally makes its own connection to the database, but I need to be able to group several calls in a transaction.
If I do that, then I need each call to use the same SqlConnection object. The SeveralCalls method would allow me to group calls together, start a transaction, and (hopefully) pass the connection to the method that will actually make the call to the sproc.

You can do this with Expressions. Everywhere you're currently using Action, use Expression<Action> instead. You can then inspect the expression object, create a new one and use the new one instead of the initial expression. Here's an example. Note the ModifyExpression method which verifies that the expression is a lambda that invokes the CallWithParams method. In this example, I'm looking at the parameters and if the second is missing or null, I programmatically create a new lambda expression with the second parameter equal to "overridden value". Note that I had to add the null values into the CallWithParams lambdas. Evidently you can't use expressions with default parameters, so I just had to give it the default value in the lambdas.
static void Main()
{
SeveralCalls(() => CallWithParams("test", null),
() => CallWithParams("AnotherTest", null));
}
public static void SeveralCalls(params Expression<Action>[] expressions)
{
foreach (var expression in expressions)
{
var modifiedExpression = ModifyExpression(expression);
var action = modifiedExpression.Compile();
action();
}
}
private static Expression<Action> ModifyExpression(Expression<Action> expression)
{
var lambda = expression as LambdaExpression;
if (lambda == null)
return expression;
var call = lambda.Body as MethodCallExpression;
if (call == null)
return expression;
var method = typeof(Program).GetMethod("CallWithParams");
if (call.Method != method)
return expression;
if (call.Arguments.Count < 1 || call.Arguments.Count > 2)
return expression;
var firstArgument = call.Arguments[0];
var secondArgument = (call.Arguments.Count == 2 ? call.Arguments[1] : null);
var secondArgumentAsConstant = secondArgument as ConstantExpression;
if (secondArgumentAsConstant == null || secondArgumentAsConstant.Value == null)
secondArgument = Expression.Constant("overridden value");
var modifiedCall = Expression.Call(method, firstArgument, secondArgument);
var modifiedLambda = Expression.Lambda<Action>(modifiedCall);
return modifiedLambda;
}
public static void CallWithParams(string someValue, string otherValue = null)
{
Console.WriteLine("SomeValue: " + someValue);
Console.WriteLine("OtherValue: " + otherValue);
}

No, I don't believe this is possible. () => CallWithParams("test") is compiled to code that calls CallWithParams("test", null), with both of those values hardcoded. There's no way (besides, potentially, some complicated reflection and/or IL emitting) to modify this in SeveralCalls.
If you could modify Main as well, this might be a good way to do it:
void Main()
{
SeveralCalls("Some other string",
otherValue => CallWithParams("test", otherValue),
otherValue => CallWithParams("AnotherTest", otherValue));
}
public void SeveralCalls(string otherValue, params Action<string>[] methodsToCall)
{
foreach (var methodToCall in methodsToCall)
{
methodToCall(otherValue);
}
}
public void CallWithParams(string someValue, string otherValue = null)
{
Console.WriteLine("SomeValue: " + someValue);
Console.WriteLine("OtherValue: " + otherValue);
}
Or:
string otherValue = null;
void Main()
{
SeveralCalls(() => CallWithParams("test", this.otherValue),
() => CallWithParams("AnotherTest", this.otherValue));
}
public void SeveralCalls(params Action[] methodsToCall)
{
this.otherValue = "Some other string";
foreach (var methodToCall in methodsToCall)
{
methodToCall();
}
}
// added static just to clarify that the otherValue here is separate from the
// one in 'this'
public static void CallWithParams(string someValue, string otherValue = null)
{
Console.WriteLine("SomeValue: " + someValue);
Console.WriteLine("OtherValue: " + otherValue);
}

No. The Action objects your SeveralCalls() method receives are opaque. You cannot discover that their invocation code happens to call CallWithParam() without using reflection and CIL inspection and disassembly.
(Doing so would be rather complicated, and would also likely not be guaranteed to be portable since the details of how the C# compiler converts lambdas into anonymous types are not guaranteed not to change. In other words it is possible only by assuming non-public implementation details of the C# compiler.)
A better solution might be to put the CallWithParams() method inside a class that contains a field or property which you can change. Then you can set this field/property as desired, and any future calls to CallWithParams() will behave accordingly. The viability/sanity of this probably depends on what you're really trying to accomplish.
In my opinion, wanting to inject a parameter into lambdas is indicative of a flawed design, so if you can share more details about why you want to do this, maybe we can help find a better solution.

No, your method accepts a generic Action. There's no way for it to be sure that the code it's calling receives one or two parameters or what type that parameter is.
You could accept an Action<string> inside the SeveralCalls-method and then pass in that value in the invocation:
void Main()
{
SeveralCalls(extra => CallWithParams("test", extra),
extra => CallWithParams("AnotherTest", extra));
}
public void SeveralCalls(params Action<string>[] methodsToCall)
{
foreach (var methodToCall in methodsToCall)
{
methodToCall("some other param");
}
}
public void CallWithParams(string someValue, string otherValue = null)
{
Console.WriteLine("SomeValue: " + someValue);
Console.WriteLine("OtherValue: " + otherValue);
}

How to avoid rewriting the same code in different methods [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 years ago.
Improve this question
OLD Question
So this is what I am trying to achieve...
I have an existing abstract class ..lets name it Class1.cs . It
contains definitions for a number of methods. So now I have included
some new functionality which needs to be implemented in each and every
method of the Class1 class. So for ex-
public void Method_1(string arg1, string arg2)
{
/*
//some code implementation specific to Method_1
*/
Dictionary<string, object> dict= new Dictionary<string, object>();
//there can be more or less arguments in other methods
dict.Add("Arg1", arg1);
dict.Add("Arg2", arg2);
Method_2(dict);
}
I have to do the exact same thing in all the methods but the arguments
can vary. So the dictionary object can have "n" parameters . Is there
a way that I can avoid the manual labor of adding the same code
repeatedly (maybe use a design pattern if possible)
i think i am not clear... bundling up the dictionary generation
mechanism is not my concern , I would still need to add the same code
in all the methods(around 50) ..I am trying to avoid manually calling
the same code again and again 50 times...
Edited and reframed the question
I have finally decided that I would build the dictionary in a private method and call that in all the other methods. Kindly ignore everything else before this paragraph.
My methods will look like this
public void Method1(string a, string b , string c)
{
Dictionary<string,object> dict = BuildDictionary(new {a, b ,c});
/*the dict object should have the following structure
key=a, value= value of a
key =b , value = value of b
key =b , value = value of b*/
}
public void Method2(string x, string y)
{
Dictionary<string,object> dict = BuildDictionary(new {x,y});
/*the dict object should have the following structure
key= x, value= value of x
key =y , value = value of y */
}
private Dictionary<string,object> BuildDictionary(params object[] values)
{
//values.ToString() gives = { a= "Value of a", b== "Vaue of b", c= "Value of c"}
//Copy pasting Simon's Code here(use of anonymous objects)
var dictionary = values.GetType()
.GetProperties()
.ToDictionary(pi => pi.Name, pi => pi.GetValue(values));
//this dictionary object gives me a count of 7 with keys as the properties of the object datatype(which is not relevant to my case).
}
So what changes do i need to make to the BuildDictionary method in order to get the desired dictionary structure?

Without much information on the nature of Method_2 and what the Keys in the dictionary represents, I'll suggest two options.
The keys always represent Arg + N
In this case, the signature of the Method_2 could be a params
public void Method_2(params object[] values)
{
var argNo = 0;
var dictionary = values.ToDictionary(x => "Arg" + ++argNo);
}
public void Method_1(string arg1, string arg2)
{
// ...
Method_2(arg1, arg2);
}
The keys represent the caller's method parameters name
A generic way to do this would be with anonymous object.
public void Method_2(object values)
{
var dictionary = values.GetType()
.GetProperties()
.ToDictionary(pi => pi.Name, pi => pi.GetValue(values));
}
public void Method_1(string arg1, string arg2)
{
Method_2(new { arg1, arg2 });
}
Edit: If Method_2 cannot be changed either, build the dictionary with a separate method with the same logic as one of the two options.
Answer to edit: The reason your implementation is not working is because you are get all the properties on an array of object and not on a (anonymous) object. You didn't copy my code completely. params object[] values should be object values.

using System.Linq;
...
// add as many elements as you want
var args = new object[] {arg1, arg2, arg3, arg4};
int i = 0;
var dict = args.ToDictionary(x => "Arg" + ++i, x => x);
Method_2(dict);
This will work, but I have no idea why you would want to pass in a dictionary to Method_2 unless you had no other choice.

You should use a loop and have a pattern for how you name your variable. In your method2 you should be able to easily finding these args.
Below, I assume that you have a list of arguments called args, and I add them all to a dictionary. Enjoy
public void Method_1(string arg1, string arg2)
{
/*
//some code implementation specific to Method_1
*/
var dict = GetArguments(args);
Method_2(dict);
}
private Dictionary<string, object> GetArguments(List<string> args)
{
Dictionary<string, object> dict= new Dictionary<string, object>();
var counter = 1;
foreach(var argItem in args)
{
dict.Add("Arg"+counter++, argItem);
}
return dict;
}

Create a private method that will construct the dictionary. You could use a simple loop or or something more concise like Matt suggested.
public void Method_1(string arg1, string arg2)
{
var dict = BuildDictionary(arg1, arg2);
Method_2(dict);
}
private Dictionary<string, object> BuildDictionary(params object[] args)
{
Dictionary<string, object> dict= new Dictionary<string, object>();
for(int i = 0; i < args.Length; i++)
{
dict.Add("Arg" + i, args[i]);
}
return dict;
}
With Matt's version:
private Dictionary<string, object> BuildDictionary(params object[] args)
{
return args.ToDictionary(x => "Arg" + ++i, x => x);
}

Is there a delegate that combines the functionality of Func<T> and Action<T>?

When you call a Action<T> you will pass in a variable of type T which will be available to the code defined in the delegate, e.g.
var myAction = new Action<string>(param =>
{
Console.WriteLine("This is my param: '{0}'.", param);
});
myAction("Foo");
// Outputs: This is my param: 'Foo'.
And when you call a Func<T> the delegate will return a variable of type T, e.g.
var myFunc = new Func<string>(() =>
{
return "Bar";
});
Console.WriteLine("This was returned from myFunc: '{0}'.", myFunc());
// Outputs: This was returned from myFunc: 'Bar'.
Here's the question -
Is there a third delegate type which will take an input parameter and also return a value? Something like -
var fooDeletegate = new FooDelegate<string, int>(theInputInt =>
{
return "The Answer to the Ultimate Question of Life, the Universe, and Everything is " + theInputInt;
});
Console.WriteLine(fooDeletegate(42));
// Outputs: The Answer to the Ultimate Question of Life, the Universe, and Everything is 42
If such a thing doesn't exist, would it possible to use Action<Func<sting>> for this sort of functionality?

You're looking for Func<T, TResult>, or one of its 15 other overloads.

There are Func<> overloads with [more than zero] parameters Func<TParam, TReturn>, Func<TParam1, TParam2, TReturn>, etc.

you can do this with new Func<inputType1, inputType2, inputType3, outputType>(). This is possible with 0 to 16 input parameters. You will find the different Func overloads in the System namespace.

Can I use params in Action or Func delegates?

When I'm trying to use params in an Action delegate...
private Action<string, params object[]> WriteToLogCallBack;
I received this design time error:
Invalid token 'params' in class, struct, or interface member declaration
Any help!

How about this workaround?
private Action<string, object[]> writeToLogCallBack;
public void WriteToLogCallBack(string s, params object[] args)
{
if(writeToLogCallBack!=null)
writeToLogCallBack(s,args);
}
Or you could define your own delegate type:
delegate void LogAction(string s, params object[] args);

Variadic type parameters are not possible in C#.
That's why there're many declarations for Action<...>, Func<...>, and Tuple<...>, for example. It would be an interesting feature, though. C++0x has them.

You could try this. It allows for any number of arguments, and you'll get a compile time error if you pass the wrong number or type of arguments.
public delegate T ParamsAction<T>(params object[] oArgs);
public static T LogAction<T>(string s, ParamsAction<T> oCallback)
{
Log(s);
T result = oCallback();
return result;
}
Foo foo = LogAction<Foo>("Hello world.", aoArgs => GetFoo(1,"",'',1.1));

You can use params in the actual declaration of a delegate, but not in type of one. The generic parameters to an Action are only types, not the actual arguments to be passed when invoking the delegate. params is not a type, it is a keyword.

I have done a minor extension to the above code from Bryan, to show how to wrap multiple method calls.
I am using this to wrap multiple methods that contain database calls, into a single transaction.
Thanks Bryan :-)
(You can run the following in LINQPad to test)
//Wrapper code
public delegate void MyAction(params object[] objArgs);
public static void RunActions(params MyAction[] actnArgs)
{
Console.WriteLine("WrapperBefore: Begin transaction code\n");
actnArgs.ToList().ForEach( actn => actn() );
Console.WriteLine("\nWrapperAfter: Commit transaction code");
}
//Methods being called
public void Hash (string s, int i, int j) => Console.WriteLine(" Hash-method call: " + s + "###" + i.ToString() + j.ToString());
public void Slash (int i, string s) => Console.WriteLine(" Slash-method call: " + i.ToString()+ #"////" + s);
//Actual calling code
void Main()
{
RunActions( objArgs => Hash("One", 2, 1)
,objArgs => Slash(3, "four") );
}
//Resulting output:
//
// WrapperBefore: Begin transaction code
//
// Hash-method call: One###21
// Slash-method call: 3////four
//
// WrapperAfter: Commit transaction code