Hide   Shrink    Copy Code

namespace IsAndAsOperators
{
    // Sample Student Class
    class Student
    {
        public int stuNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }

    }
    // Sample Employee Class
    class Employee
    {
        public int EmpNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public double Salary { get; set; }

    }
    class Program
    {

        static void Main(string[] args)
        {
            Student stuObj = new Student();
            stuObj.stuNo = 1;
            stuObj.Name = "Siva";
            stuObj.Age = 15;

            Employee EMPobj=new Employee();
            EMPobj.EmpNo=20;
            EMPobj.Name="Rajesh";
            EMPobj.Salary=100000;
            EMPobj.Age=25;

            // Is operator

            // Check Employee EMPobj is Student Type

            bool isStudent = (EMPobj is Student);
            System.Console.WriteLine("Empobj is a Student ?: {0}", isStudent.ToString());

            // Check Student stiObj is Student Typoe
            isStudent = (stuObj is Student);
            System.Console.WriteLine("Stuobj is a Student ?: {0}", isStudent.ToString());

            stuObj = null;
            // Check  null object Type
            isStudent = (stuObj is Student);
            System.Console.WriteLine("Stuobj(null) is a Student ?: {0}", isStudent.ToString());
            System.Console.ReadLine();
        }
    }

Output

Empobj is a Student ?: False
Stuobj is a Student ?: True 
Stuobj(null) is a Student ?: False

as operator

Type obj = Object as Type;

Hide   Shrink    Copy Code

namespace IsAndAsOperators
{
    // Sample Student Class
    class Student
    {
        public int stuNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }

    }
    // Sample Employee Class
    class Employee
    {
        public int EmpNo { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public double Salary { get; set; }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Student stuObj = new Student();
            stuObj.stuNo = 1;
            stuObj.Name = "Praveen";
            stuObj.Age = 15;

            Employee EMPobj=new Employee();
            EMPobj.EmpNo=20;
            EMPobj.Name="Rajesh";
            EMPobj.Salary=100000;
            EMPobj.Age=25;     

            System.Console.WriteLine("Empobj is a Student ?: {0}", CheckAndConvertobject(EMPobj));

            System.Console.WriteLine("StuObj is a Student ?: {0}", CheckAndConvertobject(stuObj));
            System.Console.ReadLine();

        }

        public static string CheckAndConvertobject(dynamic obj)
        {
           // If obj is Type student it asign value to Stuobj else it asign null
            Student stuobj = obj as Student;
            if (stuobj != null)
                return "This is a Student and his name is " + stuobj.Name;

                return "Not a Student";         


        }
    }   
}

Output:

Empobj is a Student ?: Not a Student 
StuObj is a Student ?: This is a Student and his name is Praveen

Advantage of 'as' over 'is

1. Check the Type using is
2. If it’s true then Type cast

Passing an existing transaction to the context

• You can pass null to Database.UseTransaction() to clear Entity Framework’s knowledge of the current transaction. Entity Framework will neither commit nor rollback the existing transaction when you do this, so use with care and only if you’re sure this is what you want to do.
  

• You will see an exception from Database.UseTransaction() if you pass a transaction:
• When the Entity Framework already has an existing transaction
• When Entity Framework is already operating within a TransactionScope
• Whose connection object is null (i.e. one which has no connection – usually this is a sign that that transaction has already completed)
• Whose connection object does not match the Entity Framework’s connection.

• Requires .NET 4.5.1 or greater to work with asynchronous methods.
• It cannot be used in cloud scenarios unless you are sure you have one and only one connection (cloud scenarios do not support distributed transactions).
• It cannot be combined with the Database.UseTransaction() approach of the previous sections.
• It will throw exceptions if you issue any DDL (e.g. because of a Database Initializer) and have not enabled distributed transactions through the MSDTC Service.

• It will automatically upgrade a local transaction to a distributed transaction if you make more than one connection to a given database or combine a connection to one database with a connection to a different database within the same transaction (note: you must have the MSDTC service configured to allow distributed transactions for this to work).
  
  
• Ease of coding. If you prefer the transaction to be ambient and dealt with implicitly in the background rather than explicitly under you control then the TransactionScope approach may suit you better.

The Setup Batch File