What is the difference between a static class and a namespace? (in C#)

Static class is still a class. It can contain methods, properties, etc. Namespace is just a namespace. It's just a helper to distinguish between class declarations with the same name.

Function can't live in a namespace alone, it belongs to a class.

Extensions is probably what you are looking for, if you need a static function without mentioning the name of the class.

public static class MathExtensions
{
 public static int Square(this int x)
 {
  return x * x;
 }
}
//...
// var hundredSquare = 100.Square();

As far as I understand, namespaces are a language feature only; they get removed by compilation. In other words, the .NET runtime does not "see" namespaces, just class names that happen to contain dots. For example, the String class in the System namespace is seen by the .NET runtime as a class named System.String, but there is no concept of namespace at all.

Static classes, however, are fully understood and managed by the .NET runtime. They are fully-fledged types and you can use reflection on them.

One other difference is that namespaces can span several assemblies, while classes cannot.

Yes, a static class is technically a type. It can have members (fields, methods, events). A namespace can only hold types (and it's not considered a "type" by itself; typeof(System) is a compile-time error).

There's no direct equivalent to adding a using directive for a namespace for a static class. You can, however, declare aliases:

using ShortName = ReallyReallyLongStaticClassName;

and use

ShortName.Member

when referring its members.

Additionally, you can use static classes to declare extension methods on other types and use them directly without referring to the class name explicitly:

public static class IntExtensions {
   public static int Square(this int i) { return i * i; }
}

and use it like:

int i = 2;
int iSquared = i.Square(); // note that the class name is not mentioned here.

Of course, you'll have to add a using directive for the namespace containing the class to use the extension method if the class is not declared in the root or current namespace.