.. index:: local variables' scope scope; local .. _Local-Scope: Local Scope ============ For the logic of writing functions, it is important that the writer of a function knows the names of variables inside the function. On the other hand, if you are only using a function, maybe written by someone unknown to you, you should not care what names are given to values used internally in the implementation of the function you are calling. C# enforces this idea with *local scope* rules: Variable names initialized and used inside one function are *invisible* to other functions. Such variables are called *local* variables. For example, an elaboration of the earlier program :repsrc:`return2/return2.cs` might have its ``lastFirst`` function with its local variable ``separator``, but it might also have another function that defines a ``separator`` variable, maybe with a different value like ``"\n"``. They would not conflict. They would be independent. This avoids lots of errors! For example, the following code in the example program :repsrc:`bad_scope/bad_scope.cs` causes a compilation error if the last line is uncommented. Read it, uncomment the line, and try to run it, and see: .. literalinclude:: ../../examples/introcs/bad_scope/bad_scope.cs The compilation error that Mono gives is pretty clear: The name 'x' does not exist in the current context. The the error occurs in the function ``F``. The *context* there just includes the local variables already declared in ``F``. And ``x`` is declared in ``Main``, not in ``F``, so it *does not exist* inside ``F``. We will fix this error below. If you do want local data from one function to go to another, define the called function so it includes parameters! Read and compare and try the program :repsrc:`good_scope/good_scope.cs`: .. literalinclude:: ../../examples/introcs/good_scope/good_scope.cs With parameter passing, the parameter name ``x`` in the function ``F`` does not need to match the name of the actual parameter in the calling function ``Main``. (Just the ``int`` value is passed.) The definition of ``F`` could just as well have been:: static void F(int whatever) { Console.WriteLine(whatever); } .. warning:: It is a very common error to declare a variable in one function and try to use it by name in a different function. If you get an error about a variable not existing, look to see where it was declared (or if you remembered to declare it at all)! In general the *scope* of a variable is the places in the program where its value can be referenced and used. The scope of a local variable is just inside the function where it is declared.