Q:

Delegate as function

Below function working ok but I want to make it simple. 
if (list. Exists(delegate(string s) { return s.Contains(str); }))
{
    string name = list. Find(delegate(string s) { return s.Contains(str); });
}

I am using delegate(string s) { return s.Contains(str); } 
  two times Is there any way to make this simple. 
I know how to create delegate  but don't know how to use it. 
    //create delegate       
    public delegate bool nameExistsDelegate(List<string> list, string name);

    // Create a method for a delegate. 
    public static bool IsnameExists(List<string> list, string name)
    {
        return list. Exists(delegate(string s) { return s.Contains(name) ; });
    }

    // Create a method for a delegate. 
    public static string GetName(List<string> list, string name)
    {
        return list. Find(delegate(string s) { return s.Contains(name) ; });
    }

UPDATE
stuck with .NET 2.0 so I can't use LINQ

A:

The anonymous method you're using will be converted to a Predicate<string> delegate by the compiler.  With this in mind, you can introduce a local to get rid of the redundancy you don't want. 
Predicate<string> containsStr = delegate(string s) { return s.Contains(str); };

if (list. Exists(containsStr))
{
   string name = list. Find(containsStr);
   ...
}

In C# 3.0 or later, you can express this even more succintly with lambda-expressions. 
Predicate<string> containsStr = s => s.Contains(str);

On another note, you don't need to first test that str exists and then proceed to find it (assuming the list doesn't contain nulls), you could just do:
string name = list. Find(s => s.Contains(str));
if(name ! = null)
{
   //found
}

Of course, I should also point out that strings don't contain any extra meta-data other than the characters present in them, so you don't gain anything by 'finding' a string in a list over just proving it exists (unless you meantFindIndex).