static void Main(string[] args)
{
Console.WriteLine("Hello World!");
// c# has property initializer syntax
Dog fido1 = new Dog();
fido1.Id = 1;
fido1.Name = "Fido";
fido1.Breed = "Husky";
// property initializer syntax
Dog fido2 = new Dog
{
Id = 1,
Name = "Fido",
Breed = "Husky"
};
fido1.GoTo("park");
fido1.MakeNoise();
// IAnimal is a parent type of Dog
// Dog is a subtype of IAnimal
IAnimal animal = fido1;
// converting from dog var to IAnimal var is upcasting
// upcasting is guaranteed to succeed, so it's implicit
// converting the other was is downcasting, not guar to succeed
// must be explicit with () casting
//Bird bird = (Bird)animal;
Dog dog3 = (Dog)animal;
// not all casting is upcasting or downcasting e.g. int to double and back
// double to int loses data, "unsafe", so must be explicit
int integer = (int)3.4;
//int to double cannot lose data, safe, can do with implicit cast
double num = integer;
var animals = new IAnimal[2];
animals[0] = fido1;
animals[1] = new Eagle()
{
Id = 3,
Name = "Woody"
};
// animal class can implement as many interfaces as it likes,
// but a class may only have one direct parent class
// this code doesnt care how the members are implemented
// only that they can do the job specified by the interface
foreach (IAnimal item in animals)
{
Console.WriteLine(item.Name);
item.MakeNoise();
item.GoTo("park"); // here we can't see Eagle.GoTo which only hides Bird.GoTo
// without truly overriding it
// once we use virtual/override, it does replace the method implementation
//on the object itself
}
Eagle eagle1 = (Eagle)animals[1];
eagle1.GoTo("park");
MakeNoise(dog3); //upcasting here
// use camelCase for local vars and private fields
// TitleCase aka PascalCase for everything else
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Dog fido1 = new Dog();
fido1.AnimalId = 1;
fido1.Name = "Fido";
fido1.Breed = "Doberman";
// C# has "property initializer" syntax.
Dog fido2 = new Dog
{
AnimalId = 1,
Name = "Fido",
Breed = "Doberman"
};
fido1.GoTo("park");
fido1.MakeNoise();
// IAnimal is a parent type of Dog
// Dog is a subtype of IAnimal
IAnimal animal = fido1;
// converting from Dog variable to IAnimal variable is "upcasting"
// upcasting is guaranteed to succeed, so it's implicit
// Ctrl+K, Ctrl+C to comment lines
// Ctrl+K, Ctrl+U to uncomment lines
// when the Dog object is contained in a IAnimal variable,
// we can't see the Dog-specific stuff anymore.
//animal.Breed = ""; // error
// converting the OTHER way, from IAnimal down to Dog, is "downcasting"
// NOT guaranteed to succeed, so it must be explicit with () casting
//Bird bird = (Bird)animal;
Dog dog3 = (Dog)animal;
// not all casting is upcasting or downcasting, e.g. int to double and back
// double to int loses dats, "unsafe", so, it must be explicit.
int integer = (int)3.4;
// int to double cannot lose data, "safe", so, we can do that with implicit cast.
double num = integer;
var animals = new IAnimal[2];
animals[0] = fido1;
animals[1] = new Eagle
{
AnimalId = 3,
Name = "Bill"
};
// a class can implement as many interfaces as it likes
// but, a class may only have one direct parent class
// this code doesn't care how the members are implemented,
// only that they can do the job specified by the interface.
foreach (IAnimal item in animals)
{
Console.WriteLine(item.Name);
item.MakeNoise();
item.GoTo("park"); // here, when we weren't using vrtiaul/override,
// we can't see Eagle.GoTo, which only hides ABird.GoTo
// without truly overriding it.
// once we use virtual/override, it really does replace the method implementation
// on the object itself
}
Eagle eagle1 = (Eagle)animals[1];
eagle1.GoTo("park");
MakeNoise(dog3); // upcasting here
// we use camelCase for local variables and private fields
// TitleCase aka PascalCase for everything else
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Dog fido1 = new Dog();
fido1.Id = 1;
fido1.Name = "Fido";
fido1.Breed = "Doberman";
//C# has property initializer syntax.
Dog fido2 = new Dog
{
Id = 1,
Name = "Fido",
Breed = "Doberman"
};
fido1.GoTo("park");
fido1.MakeNoise();
//IAnimal is a parent type of Dog
//Dog is a subtype of IAnimal
IAnimal animal = fido1;
//Conveting from Dog variable to IAnimal variable is "upcasting"
//Upcasting is guarenteed to succeed, so it's implicit
//converting the OTHER way, from IAnimal down to Dog, is "downcasting"
//NOT guaranteed to succeed, so it must explicit with () casting
//Bird bird = (Bird)animal; : Error
//when the Dog object is contained in an IAnimal variable, we can't
// see the Dog specific stuff anymore
// animal.Breed = ""; //error
Dog dog3 = (Dog)animal; // : Works
//not all casting is upcasting or downcasting, e.g. int to double and back
int integer = (int)3.4;
double num = integer;
var animals = new IAnimal[2];
animals[0] = fido1;
animals[1] = new Eagle()
{
Id = 3,
Name = "Bill"
};
//this code doesn't care how the members are implmented,
// only that thye can do the job specified by the interface
foreach (var item in animals)
{
Console.WriteLine(item.Name);
item.MakeNoise();
item.GoTo("park"); //here when we weren't using virtual/override
//here we can't see Eagle.GoTo, whinc only hides
//ABird.GoTo without truly overriding it
//once we use virtual/override, it really does replace the method implementation
//on the object itself
}
Eagle eagle1 = (Eagle)animals[1];
eagle1.GoTo("park");
try
{
Console.WriteLine("What should the dog say?");
string input = Console.ReadLine();
fido1.SetNoise(input);
}
catch
{
Console.WriteLine("caught ArgumentException! using fallback value");
fido1.SetNoise("woof");
}
Console.WriteLine(fido1.GetNoise());
}
static void Main(string[] args)
{
// C# has "property initializer" system
var fido1 = new Dog();
fido1.Id = 1;
fido1.Name = "Fido";
fido1.Breed = "German Shepherd";
// Much nicer syntax for doing the same thing!!!
var fido2 = new Dog
{
Id = 1,
Name = "Fido",
Breed = "German Shepherd"
};
fido1.GoTo("park");
fido1.MakeNoise();
// IAnimal is a parent type of Dog
// Dog is a subtype of IAnimal
IAnimal animal = fido1;
// converting from dog variable to IAnimal variable is upcasting
// upcasting is guaranteed to exceed so it is implicit
//when the Dog object is contained in IAnimal Variable,
// we cannot see the Dog-specific stuff anymore
// animal.Breed // error
// Converting from IAnimal to Dog is downcasting and is not guaranteed to succeed
// must be explicit with () casting
Dog dog2 = (Dog)animal;
// not all casting is up/downcasting, e.g. int to double and back
// double to int loses data and thus must be exclicit
int integer = (int)3.4;
// int to double cannot lose data however
// thus can be done implicitly
double num = integer;
var animals = new IAnimal[2];
animals[0] = fido1;
animals[1] = new Eagle
{
Id = 3,
Name = "Bob",
};
foreach (IAnimal item in animals)
{
Console.WriteLine(item.Name);
item.MakeNoise();
item.GoTo("Park"); // here we can't see Eagle.GoTo when using new
// works right when we properly override using virtual and override
}
Eagle eagle1 = (Eagle)animals[1];
eagle1.GoTo("Park");
// camel case for local variables and private fields
//Titlecase for everything else
}
