--------------------------
Post Title '.NET Assignment-1 Answers'
Post by user 'Adusumilli-Uday-Kumar'
Post encryped with secure 256-bit MD5 Encryption
Post accesable only VIA link
Post will Expire on '3-OCT-2017'
--------------------------



----
1. What is an Identifier? What's the syntax rule for Identifier?
Ans. Identifiers are the names that you use to identify the elements in your programs, such as namespaces, classes, methods, and variables. In C#, you must adhere to the following syntax rules when choosing identifiers:
- You can use only letters (uppercase and lowercase), digits, and underscore
characters.
- An identifier must start with a letter or an underscore.
For example, result, _score, footballTeam, and plan9 are all valid identifiers, whereas result%, footballTeam$, and 9plan are not.

----
2. What is a Variable? Write a note on variable naming Format. How to name a Variable?
Ans. A variable is a storage location that holds a value. You use a variable’s name to refer to the value it holds.

Naming variables:
You should adopt a naming convention for variables that helps you avoid confusion concerning the variables you have defined. The following list contains some general recommendations:
- Don’t start an identifier with an underscore.
- Don’t create identifiers that differ only by case.
- Start the name with a lowercase letter.
- In a multiword identifier, start the second and each subsequent word with an uppercase letter.
- Don’t use Hungarian notation.

Declaring variables:
Variables hold values. C# has many different types of values that it can store and process—integers, floating-point numbers, and strings of characters, to name three. When you declare a variable, you must specify the type of data it will hold. You declare the type and name of a variable in a declaration statement. For example, the statement that follows declares that the variable named age holds int (integer) values will look as follows :
-
int age;
-

----
3. What are the Primitive datatypes? Explain with Examples.
Ans. C# has a number of built-in types called primitive data types. The following table lists the most commonly used primitive data types in C# and the range of values that you can store in each.

Table Link : http://bit.ly/2xCEHL2

----
4. What are Airthematic Operators? Explain Operators and Types.
Ans. C# supports regular arithmetic operations such as the plus sign (+) for addition, the minus sign (–) for subtraction. The symbols +, –, *, and / are called operators because they “operate” on values to create new values. In the following example, the variable 'mo' ends up holding the product of 750 and 20:
-
long mo;
mo = 750 * 20;
-

Operators and Types:
Not all operators are applicable to all data types. The operators that you can use on a value depend on the value’s type. For example, you can use all the arithmetic operators on values of type char, int, long, float, double, or decimal. However, with the exception of the plus operator (+), you can’t use the arithmetic operators on values of type string, and you cannot use any of them with values of type bool.

----
5. What is Controling Precedence? Explain Associativity to evaluate Exressions.
Ans. Precedence governs the order in which an expression’s operators are evaluated. You can use parentheses to override precedence and force operands to bind to operators in a different way. For example, in the following expression, the parentheses force the 2 and the 3 to bind to the + operator (making 5), and the result of this addition forms the left operand of the * operator to produce the value 20:
-
(2 + 3) * 4
-

Using associativity to evaluate expressions:
Associativity is the direction (left or right) in which the operands of an operator are evaluated. Consider the following expression that uses the / and * operators:
-
4 / 2 * 6
-
At first glance, this expression is potentially ambiguous. Do you perform the division first or the multiplication? The precedence of both operators is the same (they are both multiplicative), but the order in which the operators in the expression are applied is important because you can get two different results. In this case, the associativity of the operators determines how the expression is evaluated. The * and / operators are both left associative, which means that the operands are evaluated from left to right. In this case, 4/2 will be evaluated before multiplying by 6, giving the result 12.

----
6. How to declare Local Variables Implicitly?
Ans. You can declare and initialize a variable in the same statement, such as:
-
int myInt = 99;
-
Or, you can even do it like this, assuming that myOtherInt is an initialized
-
integer variable:
int myInt = myOtherInt * 99;
-
Now, remember that the value you assign to a variable must be of the same type as the variable. You can also ask the C# compiler to infer the type of a variable from an expression and use this type when declaring the variable by using the var keyword in place of the type, as demonstrated here:
-
var myVariable = 99;
var myOtherVariable = "Hello";
-
The variables myVariable and myOtherVariable are referred to as implicitly typed variables. The var keyword causes the compiler to deduce the type of the variables from the types of the expressions used to initialize them. In these examples, myVariable is an int, and myOtherVariable is a string. However, this is a convenience for declaring variables only, and that after a variable has been declared you can assign only values of the inferred type to it—you cannot assign float, double, or string values to myVariable at a later point in your program, for example. You can use the var keyword only when you supply an expression to initialize a variable.

----
7. What is a Method? Write the syntax for declaring a Method.
Ans.
Creating methods:
A method is a named sequence of statements. A method has a name and a body. The method name should be a meaningful identifier that indicates the overall purpose of the method. The method body contains the actual statements to be run when the method is called. Additionally, methods can be given some data for processing and can return information, which is usually the result of the processing. Methods are a fundamental and powerful mechanism.

The syntax for declaring a C# method is as follows:
-
returnType methodName ( parameterList )
{
// method body statements go here
}
-

The following is a description of the elements that make up a declaration:
- The returnType, is the name of a type and specifies the kind of information the method returns as a result of its processing.
- The methodName, is the name used to call the method. Method names follow the same identifier rules as variable names.
- The parameterList, is optional and describes the types and names of the information that you can pass into the method for it to process.
- The method body, statements are the lines of code that are run when the method is called. They are enclosed between opening and closing braces.

----
8. Explain Expresion-Bodied Methods?
Ans. Some methods can be very simple. C# supports a simplified form for methods that comprise a single expression. These methods can still take parameters and return values, and they operate in the same way as the methods that you have seen so far. The following code examples show simplified versions of the addValues and showResult methods written as expression-bodied methods:
-
int addValues(int leftHandSide, int rightHandSide) => leftHandSide + rightHandSide;
void showResult(int answer) => Console.WriteLine($"The answer is {answer}");
-
The main differences are the use of the => operator to reference the expression that forms the body of the method and the absence of a return statement. The value of the expression is used as the return value; if the expression does not return a value, then the method is void. There is actually no difference in functionality between using an ordinary method and an expression-bodied method.

----
9. Explain how a Method is Called? What's the syntax for calling a method?
Ans. You call a method by name to ask it to perform its task. If the method requires information (as specified by its parameters), you must supply the information requested. If the method returns information (as specified by its return type), you should arrange to capture this information somehow.

The syntax of a C# method call is as follows:
-
result = methodName ( argumentList );
-

The following is a description of the elements that make up a method call:
- The methodName must exactly match the name of the method you’re calling.
- The result = clause is optional. If specified, the variable identified by result contains the value returned by the method.
- The argumentList supplies the information that the method accepts.

Examples:
-
int result = addValues(39, 3); // assignment
showResult(addValues(39, 3)); // call
-

----
10. What is Applying Scope? Define Local Scope and Class Score.
Ans. A variable can be used only after it has been created. When the method has finished, this variable disappears and cannot be used elsewhere. When a variable can be accessed at a particular location in a program, the variable is said to be in scope at that location.
You can also define variables with different scope; for example, you can define a variable outside a method but within a class, and this variable can be accessed by any method within that class. Such a variable is said to have 'class scope'.

Defining local scope:
The opening and closing braces that form the body of a method define the scope of the method. Any variables you declare inside the body of a method are scoped to that method; they disappear when the method ends and can be accessed only bycode running in that method. These variables are called local variables because they are local to the method in which they are declared; they are not in scope in any other method. The scope of local variables means that you cannot use them to share information between methods.
Consider this example:
-
class Example
{
void firstMethod()
{
int myVar;
...
}
void anotherMethod()
{
myVar = 42; // error - variable not in scope
...
}
}
-

This code fails to compile because anotherMethod is trying to use the variable myVar, which is not in scope. The variable myVar is available only to statements in firstMethod that occur after the line of code that declares myVar.

Defining class scope:
The opening and closing braces that form the body of a class define the scope of that class. Any variables you declare within the body of a class (but not within a method) are scoped to that class. The proper C# term for a variable defined by a class is field. As mentioned earlier, in contrast with local variables, you can use fields to share information between methods.
Here is an example:
-
class Example
{
void firstMethod()
{
myField = 42; // ok
...
}
void anotherMethod()
{
myField++; // ok
...
}
int myField = 0;
}
-

The variable myField is defined in the class but outside the methods firstMethod and anotherMethod. Therefore, myField has class scope and isavailable for use by all methods in that class. There is one other point to notice about this example. In a method, you must declare a variable before you can use it. Fields are a little different. A method can use a field before the statement that defines the field—the compiler sorts out the details for you.

----
11. What is Method Overloading?
Ans. If two identifiers have the same name and are declared in the same scope, they are
said to be overloaded. However, there is a certain way that you can overload an identifier for a method, without causing compile-time errors that is both useful and important.
At compile time, the compiler looks at the types of the arguments you are passing in and then arranges for your application to call the version of the method that has a matching set of parameters.
Here is an example:
-
static void Main()
{
Console.WriteLine("The answer is ");
Console.WriteLine(42);
}
-
Overloading is primarily useful when you need to perform the same operation on different data types or varying groups of information.

----
12. Explain Optional Parameters and Named Arguments.
Ans. One of the principal technologies that underpins many Windows applications and
services running outside the .NET Framework is the Component Object Model
(COM). In fact, the common language runtime (CLR) used by the .NET
Framework is also heavily dependent on COM, as is the Windows Runtime of
Windows 10. COM does not support overloaded methods; instead, it uses
methods that can take optional parameters. To make it easier to incorporate COM
libraries and components into a C# solution, C# also supports optional
parameters.
Optional parameters are also useful in other situations. They provide a compact
and simple solution when it is not possible to use overloading because the types
of the parameters do not vary sufficiently to enable the compiler to distinguish
between implementations.

----
13. Define Boolean Operators and Conditional Logical Operators.
Ans. A Boolean operator is an operator that performs a calculation whose result is either true or false. C# has several very useful Boolean operators, the simplest of which is the NOT operator, represented by the exclamation point (!). The ! operator negates a Boolean value, yielding the opposite of that value. In the preceding example, if the value of the variable areYouReady is true, the value of the expression !areYouReady is false.

Understanding conditional logical operators:
C# also provides two other binary Boolean operators: the logical AND operator, which is represented by the && symbol, and the logical OR operator, which is represented by the || symbol. Collectively, these are known as the conditional logical operators. Their purpose is to combine two Boolean expressions or values into a single Boolean result. These operators are similar to the equality and relational operators in that the value of the expressions in which they appear is either true or false, but they differ in that the values on which they operate must also be either true or false. The outcome of the && operator is true if and only if both of the Boolean expressions it’s evaluating are true.
For example, the following statement assigns the value true to validPercentage if and only if the value of percent is greater than or equal to 0 and the value of percent is less than or equal to 100:
-
bool validPercentage;
validPercentage = (percent >= 0) && (percent <= 100);
-

----
14. Explain Short Circuiting in Conditional Logical Operator.
Ans. The && and || operators both exhibit a feature called short circuiting. Sometimes, it is not necessary to evaluate both operands when ascertaining the result of a conditional logical expression. For example, if the left operand of the && operator evaluates to false, the result of the entire expression must be false, regardless of the value of the right operand. Similarly, if the value of the left operand of the || operator evaluates to true, the result of the entire expression must be true, irrespective of the value of the right operand. In these cases, the && and || operators bypass the evaluation of the right operand.

----
15. Expalin If Statement and Cascading If Statement.
Ans.
if statement syntax:

The syntax of an if statement is as follows:
-
if ( booleanExpression )
statement-1;
else
statement-2;
-

If booleanExpression evaluates to true, statement-1 runs; otherwise, statement-2 runs. The else keyword and the subsequent statement-2 are optional. If there is no else clause and the booleanExpression is false, execution continues with whatever code follows the if statement. Also, notice that the Boolean expression must be enclosed in parentheses; otherwise, the code will not compile.
Example:
-
if ( booleanExpression )
statement-1;
else
statement-2;
-

Cascading if statements:
You can nest if statements inside other if statements. In this way, you can chain together a sequence of Boolean expressions, which are tested one after the other until one of them evaluates to true.
Example:
-
if (day == 0)
{
dayName = "Sunday";
}
else if (day == 1)
{
dayName = "Monday";
}
else if (day == 6)
{
dayName = "Saturday";
}
else
{
dayName = "unknown";
}
-

----
16. Explain Switch Statement, it's Syntax and it's rules.
Ans.
switch statement syntax:
The syntax of a switch statement is as follows (switch, case, and default are keywords):
-
switch ( controllingExpression )
{
case constantExpression :
statements
break;
case constantExpression :
statements
break;
...
default :
statements
break;
}
-

The controllingExpression, which must be enclosed in parentheses, is evaluated once. Control then jumps to the block of code identified by the constantExpression whose value is equal to the result of the controllingExpression. (The constantExpression identifier is also called a case label.) Execution runs as far as the break statement, at which point the switch statement finishes and the program continues at the first statement that follows the closing brace of the switch statement. If none of the constantExpression values is equal to the value of the controllingExpression, the statements below the optional default label run.

the switch statement rules:
The switch statement is very useful, but unfortunately, you can’t always use it when you might like to. Any switch statement you write must adhere to the following rules:
- You can use switch only on certain data types, such as int, char, or string. With any other types (including float and double), you must use an if statement.
- The case labels must be constant expressions, such as 42 if the switch data type is an int, ‘4’ if the switch data type is a char, or “42” if the switch data type is a string. If you need to calculate your case label values at run time, you must use an if statement.
- The case labels must be unique expressions. In other words, two case labels cannot have the same value.
- You can specify that you want to run the same statements for more than one value by providing a list of case labels and no intervening statements, in which case the code for the final label in the list is executed for all cases inthat list.

----
17. Explain While Statement and For Statement.
Ans.
while statements:
You use a while statement to run a statement repeatedly for as long as some condition is true. The syntax of a while statement is as follows:
-
while ( booleanExpression )
statement
-

The Boolean expression (which must be enclosed in parentheses) is evaluated, and if it is true, the statement runs and then the Boolean expression is evaluated again. If the expression is still true, the statement is repeated, and then the Boolean expression is evaluated yet again. This process continues until the Boolean expression evaluates to false, at which point the while statement exits. Execution then continues with the first statement that follows the while statement.

In C#, most while statements have the following general structure:
-
initialization
while (Boolean expression)
{
statement
update control variable
}
-

for statements:
The for statement in C# provides a more formal version of this kind of construct by combining the initialization, Boolean expression, and code that updates the control variable. You’ll find the for statement useful because in a for statement, it is much harder to accidentally leave out the code that initializes or updates the control variable, so you are less likely to write code that loops forever.
Here is the syntax of a for statement:
-
for (initialization; Boolean expression; update control variable)
statement
-
The statement that forms the body of the for construct can be a single line of code or a code block enclosed in braces.

----