So, I have a base class(we can call it A) with lots of function.

Then I create a sub class of A(we can call it B) where a lot of the functions in A are disabled.

Example, here is a function from the sub class B:

public override void setSomething(boolean something)
{
      throw new Exception("This function is not supported in the sub class");
}

Is that bad and unprofessional?

I think it requires a more concrete example, but the general answer is yes. You're violating the substitution principle (and it should seem clear that despite what your hierarchy says, B is-not-an A). What are you trying to do, really?

How about letting Class A output those messages (for all functions), and only override (implement) the available functions in Class B?

This makes A more like an interface than a class, and in that case it could actually consist of pure virtual functions as I see it. (Without implementation)

(My virtual is a little rusty, but I think this qualifies, please tell me if it doesn't)

In OOP we have something called the Liskov Substitution Principle. In short:

public class BaseClass { /* stuff */ }

public class DerivedClass : BaseClass { /* stuff */ }

void someFunction(BaseClass arg) { /* do stuff */ }

//somewhere in main:

DerivedClass foo = new DerivedClass(/*stuff*/);

someFunction(foo); //Under LSP, this should NOT be an error.  Throwing exceptions can cause surprises.

Fundamentally, this is what Polymorphism, one of the "tenets" of OOP, is all about. When you define a subclass or implement an interface, not implementing something that already exists is basically telling the compiler "just kidding!" Compilers don't like surprises.

There's almost certainly a better way around your problem, but without any code we can't really say what it is.

instead of

public override void setSomething(boolean something)
{
      throw new Exception("This function is not supported in the sub class");
}

use this :

protected override void setSomething(boolean something)
{
}

or

private override void setSomething(boolean something)
{
}

so that the user of the B's class object can't call void setSomething(boolean something)

Maybe you can look for information on public, protected and private keywords ?

[EDIT]

So apparently illegal ... in C#