в 15:31, 26 мая 2010

2010-05-26T15:31:53Z

Admin: 1 версия

2010-05-26T12:16:09Z

1 версия

Новая страница

==Explicit Interface Implementation==

<source lang="csharp">using System;
interface InterfaceOne
{
void Execute();
}
interface InterfaceTwo
{
void Execute();
}
class MyImplementation: InterfaceOne, InterfaceTwo
{
void InterfaceOne.Execute()
{
Console.WriteLine("InterfaceOne.Execute implementation");
}
void InterfaceTwo.Execute()
{
Console.WriteLine("InterfaceTwo.Execute implementation");
}
}
class MainClass
{
public static void Main()
{
MyImplementation MyImplementation = new MyImplementation();

InterfaceOne InterfaceOne = (InterfaceOne) MyImplementation;
InterfaceOne.Execute();

InterfaceTwo InterfaceTwo = (InterfaceTwo) MyImplementation;
InterfaceTwo.Execute();
}
}</source>
<pre class=codeResult>InterfaceOne.Execute implementation
InterfaceTwo.Execute implementation</pre>

==Explicit interface implementation and its own implementation==

<source lang="csharp">using System;
interface InterfaceOne
{
void Execute();
}
interface InterfaceTwo
{
void Execute();
}
class MyImplementation: InterfaceOne, InterfaceTwo
{
void InterfaceOne.Execute()
{
Console.WriteLine("InterfaceOne.Execute implementation");
}
void InterfaceTwo.Execute()
{
Console.WriteLine("InterfaceTwo.Execute implementation");
}

public void Execute()
{
((InterfaceOne) this).Execute();
}
}
class MainClass
{
public static void Main()
{
MyImplementation MyImplementation = new MyImplementation();

MyImplementation.Execute();
}
}</source>
<pre class=codeResult>InterfaceOne.Execute implementation</pre>

==Explicitly implement an interface member==

<source lang="csharp">using System;

interface MyInterface {
bool MyMethodA(int x);
bool MyMethodB(int x);
}

class MyClass : MyInterface {

// Explicit implementation.
bool MyInterface.MyMethodA(int x) {
if((x%2) != 0)
return true;
else
return false;
}

// Normal implementation.
public bool MyMethodB(int x) {
MyInterface o = this; // reference to invoking object

return !o.MyMethodA(x);
}
}

class MainClass {
public static void Main() {
MyClass ob = new MyClass();
bool result;

result = ob.MyMethodB(4);
if(result) Console.WriteLine("4 is even.");

// result = ob.MyMethodA(4); // Error, MyMethodA not directly accessible

MyInterface iRef = (MyInterface) ob;
result = iRef.MyMethodA(3);
if(result) Console.WriteLine("3 is odd.");

}
}</source>
<pre class=codeResult>4 is even.
3 is odd.</pre>

==Interface member hiding==

<source lang="csharp">using System;

public interface InterfaceA
{
void MethodA();
}

public interface InterfaceB : InterfaceA
{
new void MethodA(); // hides MethodA() in InterfaceA
}
public class MyClass : InterfaceB
{
void InterfaceB.MethodA()
{
Console.WriteLine("InterfaceB implementation of MethodA()");
}
public void MethodA()
{
Console.WriteLine("InterfaceA implementation of MethodA()");
}
}

class MainClass
{
public static void Main()
{
MyClass myClass = new MyClass();
Console.WriteLine("Calling myClass.MethodA()");
myClass.MethodA();
InterfaceB mySteerable = myClass as InterfaceB;
Console.WriteLine("Calling mySteerable.MethodA()");
mySteerable.MethodA();
InterfaceA myDrivable = myClass as InterfaceA;
Console.WriteLine("Calling myDrivable.MethodA()");
myDrivable.MethodA();
}
}</source>
<pre class=codeResult>Calling myClass.MethodA()
InterfaceA implementation of MethodA()
Calling mySteerable.MethodA()
InterfaceB implementation of MethodA()
Calling myDrivable.MethodA()
InterfaceA implementation of MethodA()</pre>

==Use explicit implementation to remove ambiguity==

<source lang="csharp">using System;

interface MyInterfaceA {
int Method(int x);
}

interface MyInterfaceB {
int Method(int x);
}

// MyClass implements both interfaces.
class MyClass : MyInterfaceA, MyInterfaceB {

// explicitly implement the two Method()s
int MyInterfaceA.Method(int x) {
return x + x;
}
int MyInterfaceB.Method(int x) {
return x * x;
}

// call Method() through an interface reference.
public int MethodA(int x){
MyInterfaceA a_ob;
a_ob = this;
return a_ob.Method(x); // calls MyInterfaceA
}

public int MethodB(int x){
MyInterfaceB b_ob;
b_ob = this;
return b_ob.Method(x); // calls MyInterfaceB
}
}

class MainClass {
public static void Main() {
MyClass ob = new MyClass();

Console.Write("Calling MyInterfaceA.Method(): ");
Console.WriteLine(ob.MethodA(3));

Console.Write("Calling MyInterfaceB.Method(): ");
Console.WriteLine(ob.MethodB(3));
}
}</source>
<pre class=codeResult>Calling MyInterfaceA.Method(): 6
Calling MyInterfaceB.Method(): 9</pre>

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)

Csharp/CSharp Tutorial/Class/Explicit Interface Implementation - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия