Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating resource.

Please try to avoid dependencies to third-party libraries and frameworks.

Implementation edit is for fixing errors and enhancing with metadata.

Instead of changing the code of the snippet, consider creating another C# implementation.

Other implementations
func Contains(list []T, x T) bool {
	for _, item := range list {
		if item == x {
			return true
	return false
#include <algorithm>
std::find_if(list.begin(),list.end(),x) != list.end();
#include <vector>
#include <algorithm>
bool Contains(const std::vector<int> &list, int x)
	return std::find(list.begin(), list.end(), x) != list.end();
(define (contains list x)
        (if (null? list) #f)
        (if (equal? (car list) x) #t)
        (else (contains (cdr list) x))))
x in list
boolean contains(int[] list, int x){
  for(int y:list)
    if( y==x )
      return true;
  return false;
boolean <T> contains(T[] list, T x){
  if( x==null){
    for(T y:list)
      if( y==null )
        return true;
    for(T y:list)
      if( x.equals(y) )
        return true;
  return false;
import java.util.List;
# To check an array for a value:
print "Found 'foo'\n" if grep { $_ eq 'foo' } @a_list;

# To check a map for a value:
print "Found 'bar'\n" if exists $map{bar};
return list.indexOf(x) !== -1;
in_array($x, $list, true);
import std.algorithm.searching;
bool here = canFind(items, x);
result := false;
for e in list do 
	if e=x then
			result := true;
uses classes;
result := list.IndexOf(x) <> -1;
x `elem` list
(some (partial = x) list)
Enum.member?(list, x)
lists:member(X, List).
#include <stdbool.h>
bool contains(int x, int* list, size_t list_len) {
    for (int i=0 ; i<list_len ; i++)
        if (list[i] == x)
            return true;
    return false;
function contains(list, x)
	for _, v in pairs(list) do
		if v == x then return true end
	return false
with Ada.Containers.Vectors;
Result := List.Contains (X);
return list.includes(x);
list.iter().any(|v| v == &x)
(&list).into_iter().any(|v| v == &x)
member(_, []) -> false;
member(Value, [H|T]) -> 
  case H of
    Value -> true;
    _ -> member(T)
member(_, []) -> false;
member(Value, [H|_]) where Value =:= H -> true;
member(Value, [_|T]) -> member(Value, T).
[list containsObject:x];
list.include? x
List::Util 'first'
print "ok\n" if first {$_ eq 'needle'} @haystack;
(member x list)
(some #{x} list)
List.mem x list
x in list
if (findloc (list, x, 1) != 0) then
member(X, [One]).
if (any(x == list)) ...
find _ [] = False
find x (x:xs) = True
find x (_:xs) = find x xs
x in list