Lambda Expression Tree

Student.Where(c => c.std == "8" && c=>c.student=="student1");

// if the ID values are always the same:
private static readonly List<string> IDs = new List<string>(){ "student1", "student2", "student3" };
public static bool MatchingStudent(StudentType student, int std)
{
  // add check for student being null!!
  // use the appropriate StringComparer based on your needs
  return student.std == std && IDs.Contains(student.StudentID, StringComparer.CurrentCultureIgnoreCase);
}
// if the ID values are in some collection:
public static bool MatchingStudent(StudentType student, int std, IEnumerable<string> studentIDs)
{
  // add checks for student and studentIDs being null!!
  // use the appropriate StringComparer based on your needs
  return student.std == std && studentIDs.Contains(student.StudentID, StringComparer.CurrentCultureIgnoreCase);
}

var matching = Student.Where(s => MatchingStudent(s, 8));
// OR, depending on the cases above
var matching = Student.Where(s => MatchingStudent(s, 8, IDsCollection));

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace ConsoleApplication21
{
  class StudentType
  {
    public StudentType(int std, string id)
    {
      Std = std;
      StudentID = id;
    }
    public int Std { get; set; }
    public string StudentID { get; set; }
  }

  class Program
  {
    // The individual queries:
    static List<Tuple<int, string>> QueryInputs = new List<Tuple<int, string>> 
    { new Tuple<int, string>(8, "Student1"), 
      new Tuple<int, string>(8, "Student2"), 
      new Tuple<int, string>(8, "Student3"), 
      // If you uncomment the next line you'll see that only a single list of studentID strings is used where possible.
      //new Tuple<int, string>(9, "Student1"), 
      new Tuple<int, string>(9, "Student2"), 
      new Tuple<int, string>(9, "Student3") };

    // Test data to query against
    static List<StudentType> Student = new List<StudentType> {
      new StudentType(7, "Student1"),
      new StudentType(8, "Student0"),
      new StudentType(8, "Student1"),
      new StudentType(8, "Student3"),
      new StudentType(8, "Student2"),
      new StudentType(8, "Student10"),
      new StudentType(9, "Student0"),
      new StudentType(9, "Student2"),
      new StudentType(10, "Student3"),
    };

    // this is just to make getting the WhichStudentsInfo (MethodInfo) easier than dealing with a generic Where method
    private static IEnumerable<StudentType> WhichStudents(IEnumerable<StudentType> students, Func<StudentType, bool> test)
    {
      return students.Where(test);
    }

    private static Dictionary<int, List<string>> QuerySemantics = new Dictionary<int, List<string>>();
    private static MethodInfo ContainsInfo = typeof(List<string>).GetMethod("Contains");
    private static MethodInfo WhichStudentsInfo = typeof(Program).GetMethod("WhichStudents", BindingFlags.NonPublic | BindingFlags.Static);
    private static ParameterExpression ArgumentParameter = Expression.Parameter(typeof(StudentType), "s");
    private static ParameterExpression OuterArgumentParameter = Expression.Parameter(typeof(IEnumerable<StudentType>), "students");
    static void Main(string[] args)
    {
      foreach (var item in QueryInputs)
      {
        int queryStd = item.Item1;
        string queryStudent = item.Item2;
        // Then add to the QuerySemantics:
        List<string> studentList;
        if (!QuerySemantics.TryGetValue(queryStd, out studentList))
        {
          studentList = new List<string>();
          QuerySemantics.Add(queryStd, studentList);
        }
        studentList.Add(queryStudent);
      }
      Expression fullQueryExpression = null;
      // first go through and generate the unique multiple student lists
      Dictionary<string, string> studentListMap = new Dictionary<string, string>();
      Dictionary<string, BinaryExpression> studentListVariableExpressions = new Dictionary<string, BinaryExpression>();
      int listCounter = 0;
      foreach (var q in QuerySemantics)
      {
        var qStudents = q.Value;
        if (qStudents.Count > 1)
        {
          qStudents.Sort();
          string key = string.Concat(qStudents);  // good enough for uniqueness
          string listVar;
          if (!studentListMap.TryGetValue(key, out listVar))
          {
            listVar = "sl" + (listCounter++).ToString();
            studentListMap.Add(key, listVar);
            var varExpression = Expression.Assign(Expression.Variable(typeof(List<string>), listVar),
                                                  Expression.ListInit(Expression.New(typeof(List<string>)),
                                                                                     qStudents.Select(s => Expression.Constant(s))));
            studentListVariableExpressions.Add(listVar, varExpression);
          }
          qStudents.Insert(0, listVar);
        }
      }
      foreach (var q in QuerySemantics)
      {
        Expression queryExpression = null;
        var qStdExpression = Expression.Equal(Expression.Constant(q.Key),
                                              Expression.Property(ArgumentParameter, "Std"));
        var qStudents = q.Value;
        Expression qStudentsExpression = null;
        if (qStudents.Count > 1)
        {
          var studentListVar = studentListVariableExpressions[qStudents[0]];  // if multiple entries then 1st is var name 
          qStudentsExpression = Expression.Call(studentListVar.Left, ContainsInfo,
                                                Expression.Property(ArgumentParameter, "StudentID"));
        }
        else
        {
          qStudentsExpression = Expression.Equal(Expression.Constant(qStudents[0]),
                                                 Expression.Property(ArgumentParameter, "StudentID"));
        }
        queryExpression = Expression.AndAlso(qStdExpression, qStudentsExpression);
        if (fullQueryExpression == null)
        {
          fullQueryExpression = queryExpression;
        }
        else
        {
          fullQueryExpression = Expression.OrElse(fullQueryExpression, queryExpression);
        }
      }
      var lambdaQueryExpression = Expression.Lambda<Func<StudentType, bool>>(fullQueryExpression, ArgumentParameter);
      var variables = studentListVariableExpressions.Values.Select(lve => lve.Left).Cast<ParameterExpression>();
      var expressionsList = studentListVariableExpressions.Values.Cast<Expression>().ToList();
      expressionsList.Add(Expression.Call(WhichStudentsInfo, OuterArgumentParameter, lambdaQueryExpression));
      var whichStudentsBlock = Expression.Block(typeof(IEnumerable<StudentType>), variables, expressionsList);
      var lambdaWhichStudentsExpression = Expression.Lambda<Func<IEnumerable<StudentType>,
                                                                 IEnumerable<StudentType>>>(whichStudentsBlock,
                                                                                            OuterArgumentParameter);
      // In the Debugger ONLY you can breakpoint here and look at lambdaWhichStudentsExpression.DebugView to see what this all is!!
      var compiled = lambdaWhichStudentsExpression.Compile();
      foreach (var s in compiled(Student))
      {
        Console.WriteLine("Std: {0}, StudentID: {1}", s.Std, s.StudentID);
      }
    }
  }
}