Develop Reference

Can an interface have static variables in C#

It might be a silly question, I appreciate if someone can help me understand it.
Can an interface in C# can have static variables?
If the interface itself need to be static to declare static variables inside?
How the implementation goes for static variables(Or say property) within an interface, when we implement in a class?
Some examples and perspicuous explanation would be greatly appreciated.

No, an interface in C# can't declare fields at all. You can't declare a static interface at all in C#, nor can you declare static members within an interface.
As per section 11.2 of the C# specification:
An interface declaration may declare zero or more members. The members of an interface must be methods, properties, events, or indexers. An interface cannot contain constants, fields, operators, instance constructors, destructors, or types, nor can an interface contain static members of any kind.
All interface members implicitly have public access. It is a compile-time error for interface member declarations to include any modifiers. In particular, interfaces members cannot be declared with the modifiers abstract, public, protected, internal, private, virtual, override, or static.

An interface is a contract, ie a description of the public instance methods and properties that any implementing class must provide.
Interfaces cannot specify any static methods or properties. They cannot specify internal, protected or private methods or properties. Nor can they specify fields.

1- No, because interface is not a class
2- Consider an Abstract class
3- Static Property in an interface is not defined nor is meaningful in C#

How to define a must inherit class

How to define a must inherit class? in C#

You mark the class as abstract (this is the C# analogue to the VB.NET Must Inherit).
This will ensure it can't be instantiated directly.
From the linked MSDN article:
The abstract modifier indicates that the thing being modified has a missing or incomplete implementation. The abstract modifier can be used with classes, methods, properties, indexers, and events. Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes. Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class.
(emphasis mine)

Use the abstract modifier.
public abstract class MyClass()
{
...
}

You can define a class as abstract, or give it a protected-only constructor. abstract is better.

If u want to create a class, that has to be inherited, you'll need to mark it with the abstract modifier.
public abstract MyClass
{
}

It's not possible enforse needness of derivation or implementation in code, if that was a question.
But:
You can define an interface to force consumer to implement it.
Or you can define abstract class with only abstract members to force consumer to override all of them.
Hope this helps.

An interface would be best.
If you need to simulate the functionality , and its not a requirement that it fail at compile time...
define a method in the base class. Throw a an exception as the only line in the implementation. You might want to make the message very very clear about what the problem is.
override the method in the super class(es) and implement them.
If you fail to implement in a super class, you will get the exception.
Not perfect, but say you are trying to port code from vb.net... this could work.

What are the differences between extern, abstract, and partial for methods in an abstract class?

I am writing an abstract class because I want to provide a few commonly used methods, require a few methods that will be too specific, and allow some methods to "extended". After bumping into a compiler error I am wondering if anybody can explain the differences between the extern, abstract, and partial keywords. What do they mean and when/where should I use them?

extern is unlikely to be something you want to use. It means that the method is implemented, but implemented externally - and typically used in interop scenarios where you're defining a method implelemented in external code.
abstract, on the other hand, means you're defining the API for the method, but not providing an implementation. The subclass will have to provide the implementation for any methods or properties marked abstract, or be abstract itself. If you want to make a base class and have a method or property that must be implemented by subclasses, you'll want to use abstract.
partial classes and methods are merely a compilation tool. They allow you to use multiple files to define your type. This is mostly used with automatically generated code (ie: a designer will put the designer generated code into a separate file defining a partial class, so you can 'fill in' the missing pieces without looking at the implementation details). This is unlikely something you'll use directly for defining a class.

An extern method is typically being implemented via a dll-import (P/Invoke) - so it does have an implementation - you just can't see it.
A partial method is useful mainly with code-generation as a way to inject functionality into the generated code. They are optional, private only, and only exist if you provide the other half. As such there are also some limitations around return/out values to assure definite assignment. Calls to partial methods will be omitted entirely by the compiler if there is no implementation.
An abstract method is where the implementation has to be provided by a derived type. The runtime ensures you can't have an instance if there are still unimplemented abstract methods, so you are assured that they will exist at runtime.

There seems to be some good answers here but I would still write to make it more clear
Extern
From C# specification
When a method declaration includes an extern modifier, that method is said to be an external method. External methods are implemented externally, typically using a language other than C#. Because an external method declaration provides no actual implementation, the method-body of an external method simply consists of a semicolon. An external method may not be generic. The extern modifier is typically used in conjunction with a DllImport attribute, allowing external methods to be implemented by DLLs (Dynamic Link Libraries). The execution environment may support other mechanisms whereby implementations of external methods can be provided. When an external method includes a DllImport attribute, the method declaration must also include a static modifier.
Partial
A partial method has its signature defined in one part of a partial type, and its implementation defined in another part of the type. Partial methods enable class designers to provide method hooks, similar to event handlers, that developers may decide to implement or not. If the developer does not supply an implementation, the compiler removes the signature at compile time. The following conditions apply to partial methods:
Signatures in both parts of the partial type must match.
The method must return void.
No access modifiers are allowed. Partial methods are implicitly private.
The following example shows a partial method defined in two parts of a partial class:
Abstract
Use the abstract modifier in a method or property declaration to indicate that the method or property does not contain implementation.
Abstract methods have the following features:
An abstract method is implicitly a virtual method.
Abstract method declarations are only permitted in abstract classes
Because an abstract method declaration provides no actual implementation, there is no method body; the method declaration simply ends with a semicolon and there are no curly braces ({ }) following the signature.
It is an error to use the static or virtual modifiers in an abstract method declaration.
In this example, the class Square must provide an implementation of Area because it derives from ShapesClass:
Source
Hope this helps in better understanding, Happy coding!

Extern will allow you use methods via dll-import and by this you are giving a special meaning to that method that it's coming from external sources
Partial :
A partial method must be declared within a partial class or partial
struct
You can't have access modifier on Partial Method
A partial method cannot have access modifiers or the virtual, abstract, override, new, sealed, or extern modifiers
Partial method can't have its implementation before separate declaration.
Partial method can only be defined and can't be declared in the same partial class.
*Most important Difference between Partial and Abstract method is Partial's Implementation is optional but Abstract method's implementation is compulsory *
Abstract methods strictly require the implementation in non abstract derived class
The basic use of abstract methods is, they are required to be implemented in order to use
the class because those methods help to leverage that class efficiently

Extern: http://msdn.microsoft.com/en-us/library/e59b22c5%28v=vs.80%29.aspx
It is an error to use the abstract (C# Reference) and extern modifiers together to modify the same member. Using the extern modifier means that the method is implemented outside the C# code, while using the abstract modifier means that the method implementation is not provided in the class.
Abstract: http://msdn.microsoft.com/en-us/library/sf985hc5%28v=vs.80%29.aspx
Use the abstract modifier in a class declaration to indicate that a class is intended only to be a base class of other classes. Members marked as abstract, or included in an abstract class, must be implemented by classes that derive from the abstract class.
partial: http://msdn.microsoft.com/en-us/library/wbx7zzdd%28v=vs.80%29.aspx
Partial type definitions allow the definition of a class, struct or interface to be split into multiple files.

Why is the sealed keyword not included in the list of access modifiers?

I think sealed should be included in the list of access modifiers in C# language. Can somebody tell the reason why it has been excluded?

It's not an access modifier, it's to do with whether a class can be inherited from or not...

An access modifier defines who can access the method or class, and when (i.e.: private: only class members, public: everyone else etc). Marking a method or a class as sealed means that it cannot be inherited. It says nothing about access per se.
Properly said: you still need to add an access modifier if you use the sealed keyword (unless the default access modifier suits you).
Your confusion may be about that both keywords seem to be about protection levels. This is kind of true, but we don't have a notion of protection modifier. The sealed keyword is called the sealed modifier, because it modifies a class or method to be sealed off. This is like a boolean switch: a class or method is either sealed or it is not, regardless of its access modifiers.
To add to the confusion, there exist sealed accessors, which means that derivation of an accessor (gettor/settor) is not allowed (C# standard 10.7.5).

Cause if you cannot derive from a class it doesn't mean you cannot access it.

All the following valid class definitions feature sealed classes but they all have different levels of access, so you can see that sealed isn't an access modifier and hence isn't listed as one by Microsoft:
public sealed class MyPublicClass
{
}
internal sealed class MyInternalClass
{
}
private sealed class MyPrivateClass
{
}
You have to trust that Microsoft do know a thing or two about the language they created :)

C# syntax: Placing the interface's name in the implementation's declaration

I came across some interesting C# syntax that I'm not familiar with in the source code for the Composite Application Library for WPF's DelegateCommand<T> class.
There are some method declarations which are prefixed with the ICommand interface name, and they do not have accessibility modifiers specified. For example:
bool ICommand.CanExecute(object parameter) { ... }
What is this syntax called and where can I read more about it? I assume there's an implicit public, but I can't figure out what the benefit of specifying the class name is. My guess is that it might just be there for organization.

When you place a method like this, you're saying that this is the explicit implementation of the interface. You can read a good tutorial on MSDN via that link.
Also, a comparison might be helpful for a full view of what this means.

It's termed Explicit Interface Implementation:
If a class implements two interfaces
that contain a member with the same
signature, then implementing that
member on the class will cause both
interfaces to use that member as their
implementation.
If the two interface members do not
perform the same function, however,
this can lead to an incorrect
implementation of one or both of the
interfaces. It is possible to
implement an interface member
explicitly—creating a class member
that is only called through the
interface, and is specific to that
interface. This is accomplished by
naming the class member with the name
of the interface and a period.
Explicit Interface Implementation Tutorial

This is called explicit interface implementation and you can read about it here.
The basic idea is that those methods/properties are only accessable when explicitly used via an interface instance of that type.

It is called explicit implementation of interfaces. What it means is that this particular implementation of CanExecute will not be visible (and will not run) UNLESS the object is cast as an ICommand.
This can be useful in allowing a class to provide different implementations for different interfaces where method names overlap
public interface InterfaceOne {
void SomeMethod();
}
public interface InterfaceTwo {
void SomeMethod();
}
public class Impl : InterfaceOne, InterfaceTwo {
public void InterfaceOne.SomeMethod() {Console.WriteLine("One");}
public void InterfaceTwo.SomeMethod() {Console.WriteLine("Two");}
}
I personally hate this this syntax. Take the example of OracleParameter which provides only an explicit implementation of ICloneable.
If you have a reference to OracleParameter, the Clone() method will not appear in intellisense and will not be visible when you "Go To Definition". However the ability IS there if you do ((ICloneable)parameter).Clone(). In order to even know that this is possible, you can do that you are pretty much stuck googling around in blogs.

This is called explicit interface implementation and you can read more about it here.
In Visual Studio, if you inherit from an interface, you can right-click on the interface name in your class definition. You can click either "Implement Interface", or in the submenu, "Implement Interface Explicitly". This is a handy shortcut for implementing interfaces.