C#

Rushal Arora

Hi Everyone,

Below are the few questions in which i found difficulty :-

Q.1) Program in which we apply partial in interface?
Q.2) Why foreach loops are preffered over for loops?
Q.3) why "public static" is necessary in operator overloading?
Q.4) why interface support multiple inheritance whereas classes are
not ? Cant we do explicit implementation in classes?

Thanks and Regards

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Regarding the first question, I can't think of any scenario where you'd want to use a partial interface in practice. The situations where you'd use a partial class are not applicable to interfaces IMO.

If you're not satisfied with my other answers, then you'll need to indicate why not.

Regarding #3 and #4, these are design decisions made by the C# or .NET design teams and, unless something was said at the time or in the language specification, then one can only guess why things are done the way they are.
Rushal Arora14y ago
Thank u so much for replying.......

can u please tell me the scenario for 1st question and for rest of the questions i am not satisfied please give me some more details. Please dont get disheartened by such reply.
Vulpes14y ago
1. Although you can use the partial keyword with interfaces, it's difficult to think of circumstances in which anyone would want to. However, here's a simple program to demonstrate the concept:

using System;

partial interface IFace
{
void MyMethod();
}

partial interface IFace
{
void MyMethod2();
}

class MyClass : IFace
{
public void MyMethod()
{
Console.WriteLine("MyMethod invoked");
}

public void MyMethod2()
{
Console.WriteLine("MyMethod2 invoked");
}
}

class Test
{
static void Main()
{
IFace ifc = new MyClass();
ifc.MyMethod();
ifc.MyMethod2();
Console.ReadKey();
}
}

2. If you're not interested in an element's index within a collection, then most developers prefer to use 'foreach' rather than 'for' because it's simpler and only marginally slower to execute.

3. Operators are essentially static - they apply to the class as a whole rather than a particular instance of it. Also, operator overloading is intended as a convenience to users of a class (so they don't have to use ordinary methods) and it would make little sense for it to be only available internally. Consequently, the designers of C# decided that operators should be both static and public.

4. This again was a design decision, not just for C# but .NET generally. It was felt that there were just too many problems with multiple class inheritance, though not with multiple interface inheritance. Check out this link :

http://www.artima.com/intv/dotnetP.html