Skip to main content

Properties::Advance : C# programming for c++ programmers

Properties:

Usually inside a class we provide function GET and SET, similarly C# provides a built in mechanism called properties.

Example: 

class MyClass
{
      private int x;
      public int X
      {
get
{
   return x;
}

 set
{
   x = value;
}
}
}

After .net 3.0

class MyClass
{
     
      public int X{get;set;}  // Auto generates private feild with the name of property.
}
Note:

Static Properties:
C# also supports static properties.set/get accessor of static property can access only other static members of the class. Also static properties are invoking by using the class name.
Properties & Inheritance:

 The properties of a Base class can be inherited to a Derived class.

 Properties & Polymorphism:

 A Base class property can be polymorphicaly overridden in a Derived class. But remember that the modifiers like virtual, override etc are using at property level, not at accessor level.

Example:

using System;
class Base
{
    public virtual int X
    {
       get
       {
          Console.Write("Base GET");
          return 10;
       }
       set
       {
          Console.Write("Base SET");
       }
    }
}


class Derived : Base
{
    public override int X
    {
        get
        {
          Console.Write("Derived GET");
          return 10;
        }
        set
        {
          Console.Write("Derived SET");
        }
    }
}


Abstract Properties: 

 A property inside a class can be declared as abstract by using the keyword abstract. Remember that an abstract property in a class carries no code at all. The get/set accessors are simply represented with a semicolon. In the derived class we must implement both set and get assessors.

 If the abstract class contains only set accessor, we can implement only set in the derived class.

Example:

class MyClient
{
    public static void Main()
    {
         Base b1 = new Derived();
         b1.X = 10;
 Console.WriteLine(b1.X);//Displays 'Derived SET Derived GET 10'
    }
}
Labels:

Comments

Post a Comment

Popular posts from this blog

const used with functions

const used with functions : class Dog {    int age;    string name; public:    Dog() { age = 3; name = "dummy"; }         // const parameters and these are overloaded functions    void setAge(const int& a) { age = a; }    void setAge(int& a) { age = a; }         // Const return value    const string& getName() {return name;}         // const function and these are overloaded functions    void printDogName() const { cout << name << "const" << endl; }  // value of name can't be modified    void printDogName() { cout << getName() << " non-const" << endl; } }; int main() {    Dog d;    d.printDogName();        const Dog d2;    d2.printDogName();     }
Post a Comment
Read more

Structured Bindings

Returning multiple Values from function C++ 11 vs C++ 17 Returning compound objects Iterating over a compound collection Direct initialization Returning multiple Values from function C++ 11 vs C++ 17 :  C++ 11 (std::tie): std::tuple mytuple() {     char a = 'a';     int i = 123;     bool b = true;     return std::make_tuple(a, i, b);  // packing variable into tuple } To access return value using C++ 11, we would need something like: char a; int i; bool b; std::tie(a, i, b) = mytuple();  // unpacking tuple into variables Where the variables have to be defined before use and the types known in advance. C++ 17 : auto [a, i, b] = mytuple(); Returning compound objects :  This is the easy way to assign the individual parts of a compound type (such as a struct, pair etc) to different variables all in one go – and have the correct types automatically assigned. So let’s have a look at an ...
Post a Comment
Read more

POST 1 : std::thread in c++ | C++ 11

std::thread   C++  Thread support library std::thread. Threads enable programs to execute across several processor cores. Defined in header Class : thread Member types : native_handle_type Data Member  id    //represents the id of a thread (public member class) Member functions (constructor)    //constructs new thread object (public member function) (destructor)    //destructs the thread object, underlying thread must be joined or detached  (public member function) operator=    //moves the thread object  Observers  // Covered in NEXT POST Operations    // Covered in NEXT POST Constructor :   #include   void f1 ( int n ) { for ( int i = 0 ; i < 5 ; ++ i ) { std:: cout << "Thread 1 executing \n " ; ++ n ; std:: this_thread :: sleep_for ( std:: chrono :: milliseconds ( 10 ) ) ; ...
Post a Comment
Read more