Private
constructor: Private constructor is a special instance constructor with "private" access
modifier in a class.
It is
generally used in classes that contain static members only.
Syntax:
[Private Access Modifier] ClassName()
{
..
}
Points to remember:
A class with
private constructor cannot be inherited.
You cannot
create an object of the class which has private constructor only.
You
can create instance of class if class contain public constructor along with
private constructor.
You can use
only parameterized constructor with private constructor.
Example:
class Program
{
static
void
Main(string[] args)
{
studentPrivate.InstituteName
= "PLGP";
var ITStudent = new studentPrivate("Shivaji");
ITStudent.StudentName
= "Nagnath";
var ElectronicsStudent
= new studentPrivate("Shivaji");
ElectronicsStudent.StudentName = "Girish";
ITStudent.DisplayStudentDetails();
ElectronicsStudent.DisplayStudentDetails();
}
}
public class
studentPrivate
{
public
static
string
InstituteName;
public
string
StudentName { get; set; }
public
string
TeacherName;
public
studentPrivate(string teacher)
{
TeacherName = teacher;
}
//private Constructor
private
studentPrivate()
{
InstituteName="JNEC";
}
public
void
DisplayStudentDetails()
{
Console.WriteLine("Institute Namne: {0}", InstituteName);
Console.WriteLine("Student Name: {0}", StudentName);
Console.WriteLine("Teacher Namne: {0}", TeacherName);
}
}
Output:

Access modifiers in C#:
Encapsulation
is one of the biggest advantages of OOP, it is a process of binding the data
members and member functions into a single unit. Encapsulating data and methods
ensures independency, and limited access.
You can use
access modifiers to set the allowed access to not only classes, but also to all members of
those classes.
C# five access Specifiers:
Public :
Accessible outside the class
through object reference.
Private:
Accessible inside the class only
through member functions.
Protected :
Just like private but Accessible in
derived classes also through member functions.
Internal :
Visible inside the assembly.
Accessible through objects.
Protected Internal :
Visible inside the assembly through
objects and in derived classes outside the assembly through member functions.
Example:
namespace TestApp
{
public class student
{
//private
private string StudentCategory;
//public
public string studentName { get; set; }
//internal
internal string InstituteName { get; set; }
public static int numberOfStudents = 0;
public student()
{
numberOfStudents++;
}
public student(string caetgory)
{
StudentCategory = caetgory;
}
publicbool isEligibleForReservation()
{
if (StudentCategory !="Open")
{
return true;
}
else
return false;
}
}
}
namespace TestApp
{
class Program
{
static void Main(string[] args)
{
var firstStudent = new student("Open");
//public property
firstStudent.studentName = "Nagnath Kendre";
//internal property use
firstStudent.InstituteName = "JNEC";
Console.WriteLine("Eligible for reservation :" + firstStudent.isEligibleForReservation());
var otherStudent = new student("OBC");
otherStudent.studentName = "Balaji Kendre";
otherStudent.InstituteName = "PLGPL";
Console.WriteLine("Eligible for reservation:" + otherStudent.isEligibleForReservation());
var StudentsCount=student.numberOfStudents;
Console.WriteLine("Number of students :" + StudentsCount);
}
}
}
Property is
a class member that looks like fields or variables if you try to access using
objects, but they use accessor methods to get and set their data.
Points to remember:
1. This enables data to be accessed easily and
still helps promote the safety and flexibility of methods.
2. Properties enable a class to expose a public
way of getting and setting values, while hiding implementation or verification
code.
3. A get property accessor is used to return the
property value, and a set accessor is used to assign a new value.
4. Properties that do not implement a set
accessor are read only.
5. For auto implemented properties no custom
accessor required.
get accessor:
get acessor
is like method,It must return a value of the property type.
When you reference
the property, except as the target of an assignment, the get accessor is
invoked to read the value of the property
set accessor:
Set accessor is like method whose return type
is void. It uses an implicit parameter called value, whose type is the type of
the property.
When you
assign a value to the property, the set accessor is invoked by using an
argument that provides the new value.
Interface Properties:
You can
declare properties on interface. The accessor of an interface property does not
have a body. Thus, the purpose of the accessors is to indicate whether the
property is read-write, read-only, or write-only.
Syntax:
[attributes] [new] type identifier {interface-accessors}
more info...http://codechef4u.com/post/2015/07/02/Interface-Properties
Read-only Properties:
You can also
create read-only properties if you avoid setting accessor method. For example,
to
make the
Name property a read-only property, you use this code:
class Product
{
private string name;
public string Name
{
get
{
return name;
}
}
}
Static Properties:
You can create static properties in C# like fields, which
means you don’t need an object to use them.
public class student
{
private static int numberOfStudents = 0;
public student()
{
numberOfStudents++;
}
public static int NumberOfStudents
{
get
{
return numberOfStudents;
}
set
{
numberOfStudents =value;
}
}
}
Auto implemented properties:
In C#3.0 and
above Microsoft introduced feature called auto implemented properties.
For auto implemented
properties no custom accessor required. They also enable client code to create objects.
When you declare a property, the compiler creates a private, anonymous backing
field that can only be accessed through the property's get and set accessors.
Example:
public class
Product
{
string
ProductUseCategory;
private
string
name;
public
Product(string cetgory)
{
ProductUseCategory
=cetgory;
}
//auto
implemented properties
public
int
ProductID { get; set; }
//simple property declartion
public
string
ProductName
{
get
{
return
name;
}
set
{
name = value;
}
}
public
double?
UnitPrice { get; set; }
public
bool
isProductSellable()
{
if
(ProductUseCategory== "Expired")
{
return
false;
}
else
{
return
true;
}
}
}