C# basic calculator

The other answers already give very good advice, but let's dig a bit deeper.

I used things like "static" and "void" but didn't use a "class"; does adding class make it better and how can it make it better?

Classes and other features like namespaces help to organize and reuse code. Every language has some features that help in this regard. For such a simple example you can get away without them, but once a program has a lot more functionality, uses external libraries - or is used itself by other programs - these become important. C# used to require that everything is placed in namespaces and classes, over the last years some of it became optional to facilitate simple programs and scripts. Under the hood, all these are still there and just get automatically generated for you.

Or I used "WriteLine" and "ReadLine" separately; is there a better way to output a text and getting an input?

For such a simple questions-answer "game" this is totally fine. Command line pograms usually are made so that they can perform their job without requiring input during execution by reading everything they need from arguments given to them at the start. A calculator could for example be called like Calculate.exe 42+23 and then interprete what it is asked to do.

Another path forward is to build a graphical user interface (GUI) for the calculator. This is why Jesse pointed out that your calculation methods should not handle output as well. It would just not work when used in another context.

Let's look at a few other things we can do with the code. None of these are required, but they might point you toward possible paths forward. I'll just explain it in the code via comments.

// First: Well, comments.
// It's hard to find the sweet spot. You'll want to help others (or yourself)
// explain why you did something, but not what you do, that's what the code is for.

// As explained, these computation methods should not handle output to the console.
// We'll do that further down.
//
// Your original version used int as type for numbers.
// That works well with most computations, but gives strange results for division.
// Let's use double instead. It has other drawbacks, but is much closer to what
// you would expect a calculator to do.
//
// And such small methods that just return a value can be written in a
// very short way in C#:
static double Plus(double a, double b) => a + b;
static double Minus(double a, double b) => a - b;
static double Times(double a, double b) => a * b;
static double Divide(double a, double b) => a / b;

// You ask for a number, but what happens when the user enters "two"?
// Your program just crashes. That's not nice. So we do some basic error handling.
// We'll come back to it later.
try
{
    // As input we still only allow int(eger) numbers, also known as Int32.
    // But C# let's us convert these to doubles just by declaring the variable it
    // gets assigned to as such. There are many other methods to do that,
    // but for now this is fine.
    Console.WriteLine("Enter the first number: ");
    double a = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("Enter the second number: ");
    double b = Convert.ToInt32(Console.ReadLine());

    Console.WriteLine("Which operation? (+, -, *, /)");
    string op = Console.ReadLine() ?? "";

    // Using "switch" to simplify a lot of "if/else" checks was already mentioned.
    // This here is a shorter version that can be used in simple cases.
    // And in case we don't recognize the operator, we throw an exception to
    // indicate something bad happened. This is part of the error handling
    // and will be dealt with further down.
    var c = op switch
    {
        "+" => Plus(a, b),
        "-" => Minus(a, b),
        "*" => Times(a, b),
        "/" => Divide(a, b),
        _ => throw new NotSupportedException("Incorrect operation entry!"),
    };

    // The output is handled the same way for all computations.
    // There are a lot of ways to create strings from data, here we do
    // string interpolation with formatting. See the ":F" after the "c"?
    // This indicates that we want to format the number with a maximum of
    // 2 digits after the decimal separator. I always have to look these up ...
    //
    // By the way: when an exception is thrown above, we won't even get here.
    // Instead we jump directly to the catch statement below.
    Console.WriteLine($"{a}{op}{b} = {c:F}");
}
catch (Exception ex)
{
    // We only enter this catch block when an exception was thrown inside the 
    // try block above. Could be that someone entered text instead of a number
    // (Convert.ToInt32 would then throw a "FormatException"),
    // could be that they typed in an operator we don't support.
    // This way the user knows what happens and can do better the next time.
    Console.WriteLine($"Error: {ex.Message}");
}

Without the comments this is much shorter than your version and has basic error handling. But it is still easy to read ... once you get used to C#.