C#

class Employee 
        {
            public void Talk()
            {
                MessageBox.Show("I am an Employee.");
            }
        }

        class ContractEmployee: Employee 
        {
            public void ContractTalk()
            {
                MessageBox.Show("I am a Contract Employee.");
            }
        }

static void CreateEmployee()
        {
            Employee e = new ContractEmployee();
            e.Talk();
            e.ContractTalk();
        }

interface IEmployee
        {
            void Talk();
        }

        abstract class Employee : IEmployee
        {
            public abstract void Talk();
        }

        class PermanentEmployee:Employee
        {
            public override void Talk()
            {
                MessageBox.Show("I am a Permanent Employee.");
            }
        }

        class ContractEmployee: Employee 
        {
            public override void Talk()
            {
                MessageBox.Show("I am a Contract Employee.");
            }
        }

static void CreateEmployee()
        {
            Employee e = new ContractEmployee();
            e.Talk();
            e = new PermanentEmployee();
            e.Talk();
        }

class Employee { }

class ContractEmployee : Employee { }

class CastExample2
{

    public static void Main ()
    {
        ContractEmployee ce = new Employee(); // Won't compile.
    }
}

nstk wrote:

And this is ok for me, but still I do not understand why is such a declaration useful and what it actually means. If I declare

Employee e = new ContractEmployee()

and e has the properties of the Employee class, why then not write

Employee e = new Employee()

as we "normally" do? What is the difference between those two?

MicroVirus wrote:

The difference between the two lines is that in the first, e behaves like a ContractEmployee and in the second e behaves like an Employee.

abstract class Animal {
 public abstract string Noise { get; }
 public virtual string Feed() { return "Mm, tasty."; }
}

class Dog : Animal {
 public override string Noise { get { return "Woof."} }
 public void GiveBone() { Console.WriteLine("Chomp."); }
}

class Cow : Animal {
 public override string Noise { get { return "Moo."; } }
 public override string Feed() { return "I'll only eat it if it's green."; }
}

void FeedAndListen(Animal animal){
 Console.WriteLine(animal.Feed());
 Console.WriteLine(animal.Noise);
 // You can't do this, because the animal type is not known
 // animal.GiveBone();
}

static void Main(){
 List<Animal> animals = new List<Animal>();
 animals.Add(new Dog());
 animals.Add(new Cow());
 foreach(Animal animal in animals) FeedAndListen(animal);
}

BobJanova wrote:

Code which does not know about ContractEmployee can still call methods on it if they are overrides of virtual (or abstract or interface-defined) methods of a base class.

class Employee 
{
    public void Talk()
    {
        MessageBox.Show("I am an Employee.");
    }
}

class ContractEmployee: Employee 
{
    public void ContractTalk()
    {
        MessageBox.Show("I am a Contract Employee.");
    }
}

static void CreateEmployee()
{
    Employee e = new ContractEmployee();
    e.Talk();
    ((ContractEmployee)e).ContractTalk();
}

static void CreateEmployee()
{
    Employee e = new Employee();
    e.Talk();
    ((ContractEmployee)e).ContractTalk(); // Here you will get an exception at runtime. Compliler won't find any errors.
}

class Employee
{
    public string Name { get; set; }
}

class ContractEmployee : Employee
{
    public object Contract { get; set; }
}

class Program
{
    static void Main()
    {
        Employee e = new ContractEmployee();
        e.Name = "Ricky"; // No problem with this
        e.Contract = new object(); // Problem: this does not compile
    }
}

nstk wrote:

which properties and methods does the object e has?

((ContractEmployee)e).Contract = new object();

// or

ContractEmployee ce = (ContractEmployee)e;
ce.Contract = new object();

nstk wrote:

how should I read this?

  1  Employee e = new ContractEmployee();
  2  Debug.Assert (e is Employee);
  3  Debug.Assert (e is ContractEmployee());

  1  Employee e = new ContractEmployee();
  2  ContractEmployee ce = e as ContractEmployee;  // unsafe casting; better to use the cast operator
  3                                                // (ContractEmployee) which will throw on failure
  4  Debug.Assert (ce != null);

nstk wrote:

Or maybe it's the opposite that is true?

Test(double b_):this(b_,c)

public Test(double b_)
{
  double c_ = ...
  Initialize(b_, c_);
}
public Test(double b_, double l)
{
  Initialize(b_, l);
}
private void Initialize(double b_, double l)
{
  ...
}

public Test(double b) : this(b, b * Math.Sqrt(44)) { ...

venomation wrote:

I do not understand

venomation wrote:

The problem is that when it is rendered the grid does not render correctly

venomation wrote:

I do not understand