Beispiel #1
0
        static void Main(string[] args)
        {
            var fido = new Dog()
            {
                Id    = 1,
                Name  = "Fido",
                Breed = "Pug"
            };

            fido.GoTo("Park");
            fido.MakeNoise();

            //IAnmial is parent type of Dog.
            //Dog is subtype of IAnimal

            var animals = new IAnimal[2];

            animals[0] = fido;
            animals[1] = new Eagle()
            {
                Id   = 2,
                Name = "Chirpy"
            };

            foreach (var Item in animals)
            {
                Console.WriteLine(Item.Name);
                Item.MakeNoise();
            }
        }
Beispiel #2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            Dog fido1 = new Dog();

            fido1.AnimalId = 1;
            fido1.Name     = "Fido";
            fido1.Breed    = "Doberman";


            Dog fido2 = new Dog
            {
                AnimalId = 1,
                Name     = "Fido",
                Breed    = "Doberman",
            };


            fido1.GoTo("Park");
            fido1.MakeNoise();


            IAnimal animal = fido1;

            //animal.Breed = "";
            //Bird bird = (Bird)animal;

            Dog dog3 = (Dog)animal;


            int integer = (int)3.4;

            double num = integer;


            var animals = new IAnimal[2];

            animals[0] = fido1;
            animals[1] = new Eagle
            {
                AnimalId = 3,
                Name     = "Bill"
            };



            foreach (var item in animals)
            {
                Console.WriteLine(item.Name);
                item.MakeNoise();
                item.GoTo("Park");
            }


            MakeNoise(dog3);//upcasted to the function below with the static call.
        }
Beispiel #3
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            var fido1 = new Dog();

            fido1.AnimalId = 1;
            fido1.Name     = "Fido";
            fido1.Breed    = "Doberman";

            var fido2 = new Dog
            {
                AnimalId = 1,
                Name     = "Fido",
                Breed    = "Doberman"
            };

            fido1.GoTo("park");
            fido1.MakeNoise();

            IAnimal animal = fido1;

            //animal.Breed = "";

            //Bird bird = (Bird)animal;
            Dog dog3 = (Dog)animal;

            int    integer = (int)3.4;
            double num     = integer;

            var animals = new IAnimal[2];

            animals[0] = fido1;
            animals[1] = new Eagle
            {
                AnimalId = 3,
                Name     = "Bill"
            };

            foreach (var item in animals)
            {
                Console.WriteLine(item.Name);
                item.MakeNoise();
                item.GoTo("park");
            }

            Eagle eagle1 = (Eagle)animals[1];

            //eagle.GoTo

            MakeNoise(dog3);

            // use camelcase for local variables and private fields
            // TitleCase aka PascalCase for everything else
        }
Beispiel #4
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            var fido1 = new Dog();

            fido1.ID    = 1;
            fido1.Name  = "Fido";
            fido1.Breed = "Doberman";

            var fido2 = new Dog()
            {
                ID    = 2,
                Name  = "Fido",
                Breed = "DoberMan"
            };

            fido1.GoTo("park");
            fido1.MakeNoise();

            IAnimal animal = fido1;
            Dog     dsdf   = (Dog)animal;
            //Bird twdsf = (Bird)animal;
            int integer = (int)3.5;

            Console.WriteLine(integer);
            Console.WriteLine("**********************");

            var animals = new IAnimal[2];

            animals[0] = fido1;
            animals[1] = new Eagle()
            {
                ID    = 1,
                Breed = "ere2e"
            };
            foreach (var item in animals)
            {
                Console.WriteLine(item.Breed);
                item.MakeNoise();
                item.GoTo("park");
            }
            Console.ReadLine();
        }
Beispiel #5
0
        static void Main(string[] args)
        {
            var scotch = new Dog();

            scotch.Id    = 1;
            scotch.Name  = "Scotch";
            scotch.Breed = "Labrodoodle";

            var badge = new Dog()
            {
                Id    = 2,
                Name  = "badge",
                Breed = "Airedale"
            };

            scotch.GoTo("Window");
            scotch.MakeNoise();

            IAnimals animal = scotch;

            var animals = new IAnimals[4];

            animals[0] = scotch;
            animals[1] = badge;
            animals[2] = new Bird
            {
                Name = "Olive",
                Id   = 3
            };
            animals[3] = new Dog
            {
                Name = "Sam",
                Id   = 4
            };

            foreach (IAnimals item in animals)
            {
                Console.WriteLine(item.Name);
                item.MakeNoise();
            }
            //MakeNoise(animals[3]);
        }
Beispiel #6
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            var fido1 = new Dog();

            fido1.AnimalId = 0;
            fido1.name     = "fido";
            fido1.Breed    = "Doberman";

            var fido2 = new Dog
            {
                AnimalId = 1,
                name     = "fido",
                Breed    = "Doberman"
            };

            fido1.GoTo("park");
            fido1.MakeNoise();

            //upcasting is automatic
            //downcasting must be explicit, since it is not guaranteed to succeed
            int integer = (int)3.4;

            var animals = new IAnimal[2];

            animals[0] = fido1;
            animals[1] = new Eagle
            {
                AnimalId = 3,
                name     = "Bill"
            };

            //hiding only works when variable is the type of the lower!
            //So it shouldn't be used

            foreach (IAnimal item in animals)
            {
                Console.WriteLine(item.name);
                item.MakeNoise();
            }
        }
Beispiel #7
0
        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
        }
Beispiel #8
0
        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
        }
Beispiel #9
0
        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
        }