C# pls explain to me simple English language...

Alex

pls explain the difference between local,class-level and public variables.

and difference between method that is void and method is not void...

thanks for answer for advance

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
Accepted answer
A local variable is a variable declared in a method or property. It cannot be accessed by code outside that method or property.

A class-level variable (or field) is a variable defined within a class but outside any method or property of that class. It can be accessed by all code within the class.

A public variable is a class-level variable which can be accessed not only by all code within the class but by all code outside the class as well.

A void method does not return a value.

A non-void method does return a value, though this value can be discarded if you don't need it.

For example:

public class MyClass
{
int MyInt; // class-level variable

public string MyString; // public variable

public void MyMethod()
{
Console.WriteLine("I'm a void method because I don't return a value");
}

public int MyMethod2()
{
int i = 42; // local variable
Console.WriteLine("I'm a non-void method because I return an int");
return i;
}
}
0
Alex13y ago
thanx a lot
0

Sunny Sharma13y ago

Hi Alexandra,

In your question, Local, Class-Level and Public variables, all stand in regard of the their Scope while being accessed inside your program.

In case when a variable is declared inside a class we call it local to that class. It also would be a Class-Level variable. A public variable is that you can access from outside the class.
See the example below:
------------------------------

  class MyClass

        {             private string MY_SSN;             public string MY_NAME;

        }

-------------------------------
Above is a sample class having two variables My_SSN, MY_NAME. Here MY_SSN is declared private. Hence it's only accessible to its Class members. All methods inside MyClass can access and use this variable, but this would be inaccessible from outside of this class. Here MY_SSN is a Local variable to the class MyClass so a Class-Level variable as well. Variable MY_NAME is declared as public and so is accessible from outside of the class, so called a public variable. 

Hope I've made myself clear on Variable's Scope.

Now coming to the point of Void and Not Void:
Let's take a sample method for example:
--------------------------------------------
void PrintMyName()         {             Console.WriteLine("Your name is : Sunny.");         }
--------------------------------------------

by putting a "void" keyword we declare that the method is going to return nothing, It is just intended to do something but return nothing. Whereas if you declare a return Data type, then the method is supposed to return that Data type from inside of the method, like:
--------------------------------------------
string GetMyName()         {             return "Your name is : Sunny.";         }
--------------------------------------------

You can compare the two sample methods above and confirm that first returns nothing, 
just prints a message to the console whereas the second returns the string back.

I hope you're clear with the idea about void and Non-Void Methods now.

Mark this as answer if it helps.

cheers!

inthiyaz13y ago
Local : only within the method and can not be accessible out side if the method scope.
class level: entire class level and can not be accessible out side of the class scope.
public:within the name space, can be access any class within the name space and cant accessible out side of the name space.

following snippet will help for better understand..

namespace nA
{
          //Global declarations
        public string aglobal="public/global level";
                class A
                 {
                  //Class level declarations
                         string aclass="class level";
                         public void methodA()
                                 {
                                  //Method level declarations
                                         string alocal="method level";
                                         console.write(a);
                                 }
                  }
                 class B
                   {
                         string aclass="class level";
                         public void methodA()
                                 {
                                         string alocal="method level";
                                         console.write(a);
                                 }
                 }

}
0