Some scenarios I came across while working with C# where OOPs funda deviated at some level to provide more flexibility. Suggest me some more scenarios if I miss anyone.

1. Articles from Jinal Desai .NET
OOPS With CSharp
2012-11-10 13:11:59 Jinal Desai
Some scenarios I came across while working with C# where OOPs funda deviated
at some level to provide more flexibility. Suggest me some more scenarios if I miss
anyone.
Scenario # 1.
Two interface having same method signature is derived by a class.
How to implement methods in a class with same signature from different
interfaces?
We can use named identifiers to identify the common method we implemented
based on two different interfaces.
i.e. If there is two interfaces i1 and i2, both has one method with same signature
(void test(int a)), then at the time of implementing these methods inside class “abc”
we can use i1.test and i2.test to differentiate the implementation of methods from
two different interfaces having same signature.
Interface i1
{
void test(int a);
}
interface i2
{
void test(int a);
}
public class abc: i1, i2
{
void i1.test(int a)
{
Console.WriteLine(“i1 implementation: “ + a);
}
void i2.test(int a)
{
Console.WriteLine(“i2 implementation: “ + a);
}
}
Note : The only thing that can be noted here is that at the time of implementing test()
methods from two different interfaces in a single class, the public modifier is not

2. required. If you define public modifier for the implementation of test() method in
class “abc” then it will give you error “The modifier ‘public’ is not valid for this item”.
How to call those implemented methods from another class?
To access methods implemented in a class “abc” into another class, we need to
use respected interface rather than class “abc”.
i.e. If I need to use method of interface i1 then I need to do code as follow.
i1 testi1=new abc();
i1.test(10);
Above code will call test() method of interface i1. In the similar manner we can call
test() method of interface i2. If we need to call both the method with one instance of
class “abc” then we need to cast “abc” class into an interface of which method we
are intended to call as demonstrated below.
abc testabc=new abc();
(testabc as i1).test(10);
(testabc as i2).test(10);
What if I has a method inside class “abc” with same signature prototyped in
interface i1 and i2 (those interfaces we have implemented in class “abc”)?
In that case we can call the method in a normal way with the instance of class
“abc”.
i.e.
public class abc: i1, i2
{
void i1.test(int a)
{
Console.WriteLine(“i1 implementation: “ + a);
}
void i2.test(int a)
{
Console.WriteLine(“i2 implementation: “ + a);
}
void test(int a)
{
Console.WriteLine(“Normal method inside the class: ” + a);
}
}
//To call the method normally.
abc testabc=new abc();
testabc.test(10);
How we can access implemented method of i1 from inside the implemented

3. method of i1, in a class “abc” or vice-versa?
It’s simple. We need to cast “this” into respected interface to use it’s method.
i.e.
public class abc: i1, i2
{
void i1.test(int a)
{
Console.WriteLine(“i1 implementation: “ + a);
}
void i2.test(int a)
{
Console.WriteLine(“i2 implementation: “ + a);
(this as i1).test(a + 20);
}
}
Scenario #2
Which are the things allowed inside an interface in case of C#? (In other way
can automated property/event/delegate…etc allowed inside an interface
while using C#.NET?)
First thing first is method signature can be declared in an interface, it is the purpose
of an interface. Except method signature, property declaration and event declaration
are also allowed inside an interface.
Property Declaration inside an Interface
interface Itest
{
int a { get; set; }
int b { get; set; }
}
The only thing you need to care here is that, you need to implement these properties
in an implemented class. Compiler will not understand these declared properties as
automated properties. In a class if we write properties like this then it should be
considered as an automated properties, implementation is not required in that case.
i.e. Implementation of properties defined in Itest
class Test:ITest
{
int aVar = 0;
int bVar = 0;
public int a
{
get
{

4. return aVar;
}
set
{
aVar = value;
}
}
public int b
{
get
{
return bVar;
}
set
{
bVar = value;
}
}
}
Event Declaration inside an Interface
public delegate void ChangedEventHandler
(object sender, EventArgs e);
interface Itest
{
event ChangedEventHandler Changed;
}
Now to use this event inside the implemented class, following is an example.
Class Test: Itest
{
public void BindEvent()
{
if(ChangedEventHandler!=null)
Changed+=new ChangedEventHandler(Test_Changed);
}
void Test_Changed(object sender, EventArgs e)
{
//Event Fired
}
}
This way you can confirm that all the implementer classes implemented the event to
become sync with the interface design. So that all the classes can be called in a
similar pattern designed by an interface.
Scenario #3

5. I have one interface Itest as defined below.
Interface Itest
{
int sum(int a, int b);
}
I have implemented the interface into Calculator class as follow.
Class Calculator:ITest
{
public int sum(int a, int b)
{
return (a+b);
}
}
I have one more class named ScientificCalculator derived from Calculator class
having same method with same signature.
Class ScientificCalculator:Calculator
{
public int sum(int a, int b)
{
return base.sum(a,b);
}
}
Can it be possible to access sum method of calculator class if I created instance of
ScientificCalculator class by assigning it to interface Itest?.
i.e.
Itest itest = new ScientificCalculator();
Now is it possible to access sum method of Calculator class through object itest?
Yes, we can access it but for that we need to cast itest object into Calculator class.
((Calculator)itest).Sum(20, 30);
If you access directly sum method then it obviously refer sum method of class
ScientificCalculator.