CODEWITHSUNDEEP
c#lambda
Hurricane
Hurricane

Reputation: 163

Anonymous method with return

Please tell me what is wrong and how to write annonymous method with return for this impementation

public class Test 
{
    public string Implisity { get; set; }

}

class Program
{
    static void Main(string[] args)
    {
        /*Here is a problem */
        var variable = Method(delegate(IList<string> i, List<string> j){ return new Test(){Implisity = i[j.IndexOf("Implisity")]}; });
    }

    public static List<T> Method<T>(Func<IList<string>, IList<string>, T> staff) { return new List<T>(){staff(new List<string>() {"1","2"}, new List<string>(){"Explisity","Implisity"})}; }
}

this is a flat method what as me need to make annonymous 

    public static Test Annonymous(IList<string> i, List<string> j) 
    { 
        var obj = new Test() { Implisity = i[j.IndexOf("Implisity")] };
        return obj;
    }

Upvotes: 1

Views: 85

Answers (2)

ocuenca
ocuenca

Reputation: 39386

Try this:

 var variable = Method((i, j) => new Test() { Implisity = i[j.IndexOf("Implisity")] });

A lambda expression is an unnamed method written in place of a delegate instance. The compiler immediately converts the lambda expression to either:

  • A delegate instance.
  • An expression tree, of type Expression<TDelegate>, representing the code inside the lambda expression in a traversable object model. This allows the lambda expression to be interpreted later at runtime

Upvotes: 2

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 727127

The problem is that the Method(...) method expects a Func<...> with different parameter types: it expects a method that takes two IList<string> objects, while you are making a delegate that takes an IList<string> and a List<string>

var variable = Method(
    delegate(IList<string> i, IList<string> j) {
    //                        ^
        return new Test() {
            Implisity = i[j.IndexOf("Implisity")]
         };
    }
);

To avoid issues like this in the future, use implicit typing, like this:

var variable = Method( (i, j) => new Test { Implisity = i[j.IndexOf("Implisity")] } );

In this example, the compiler knows what the parameter types of the function must be from the signature of the Method(...) method, so it implicitly assigns the types to i and j.

Upvotes: 4

Related Questions