The document discusses key concepts in C# programming including variables, data types, flow control, enums, namespaces, the Main method, console I/O, preprocessor directives, and programming guidelines. It provides syntax examples for declaring variables, initializing variables, constants, conditional and loop statements, and namespaces. It also describes the Console class, XML documentation comments, and preprocessor directives.

2.  Variables
 Predefined Data Types
 Flow Control
 Enumerations
 Namespaces
 The Main() Method
 Compiling C# Files
 Console I/O
 C# Preprocessor Directives
 C# Programming Guidelines

3.  Syntax for Declaring a variable
 [access-specifier] datatype variable_name;
 Ex: int a;
 Initialization of Variables
 Global variables has default values
 Local variable must be explicitly initialized before use
it.

4. • The scope of a variable is the region of code from
which the variable can be accessed.
◦ The scope is determined by fallowing rules
 A member variable of a class is in scope for as long as
its containing class is in scope.
 The local variable is in scope until closing brace
indicates the end of the block.

5.  A constant variable is a variable whose value can
not be changed throughout its life time.
 Syntax for Constants
◦ const datatype var_name=value;
◦ Constants have fallowing Characteristics
 They must be initialized when they are declared and it can
never be over written.
 The value of a constant must be computable at compile time .

6.  Types of Data Types
◦ Value Types
 Value types are stored in an area known as Stack
◦ Reference Types
 Reference types stored in an area known as Managed Heap.
◦ CTS Types
 The basic predefined types recognized by C# are not
intrinsic to the language but are part of .NET Framework.

8.  Conditional Statements
 When you use a conditional statement, you can specify
a condition and one or more commands to be
executed, depending on whether the condition is
evaluated to true or false.
 If, if-else, switch.
 Loops
 The loop executes a statement or a block of
statements repeatedly until a specified expression
evaluates to false.
 for, while, do-while, foreach.

9.  Jump Statements
◦ Branching is performed using jump statements,
which cause an immediate transfer of the program
control.
◦ The following keywords are used in jump
statements:
 break
 return
 continue
 goto
 throw

10.  An enumeration type (also named an enum) provides an
efficient way to define a set of named integral constants
that may be assigned to a variable.
 The enum keyword is used to declare an enumeration, a
distinct type that consists of a set of named constants
called the enumerator list.
◦ Ex: enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday }; //by default Sunday=0…Saturday=6
◦ enum Months : byte { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep,
Oct, Nov, Dec };
 By default the underlying type of each element in the enum
is int. You can specify another integral numeric type by
using a colon, as shown in the previous example.
 By default, the first enumerator has the value 0, and the
value of each successive enumerator is increased by 1.

11.  Namespaces provide a way of organizing related
classes and other types.
 The namespace keyword is used to declare a
scope. This namespace scope lets you organize
code and gives you a way to create globally
unique types.
 Syntax to create namespaces
 namespace namespace_name
{
class class_name{…..}
}

12.  using Directive
 The using directive has two uses:
◦ To allow the use of types in a namespace so that
you do not have to qualify the use of a type in that
namespace:
 using System.Text;
◦ To create an alias for a namespace or a type. This is
called a using alias directive.
 using Project = PC.MyCompany.Project;

13.  The Main method is the entry point of a C#
console application or windows application
(Libraries and services do not require a Main
method as an entry point).
 When the application is started, the Main method
is the first method that is invoked.
 There can only be one entry point in a C#
program.
 If you have more than one class that has a Main
method, you must compile your program with the
/main compiler option to specify which Main
method to use as the entry point.

14.  Main must be static and it should not be
public.
 Main can either have a void or int return type.
 The Main method can be declared with or
without a string[] parameter that contains
command-line arguments.

15.  The parameter of the Main method is a string
array that represents the command-line
arguments.
◦ static void Main(string[] args) {….}
 Usually you check for the existence of the
arguments by testing the Length property.
◦ if (args.Length == 0) {//Inform user}

17.  Console class represents the standard input,
output, and error streams for console
applications.
 This class cannot be inherited.
 Some Methods in Console Class are
◦ Write()
◦ WriteLine()
◦ ReadLine()
◦ Clear()
 We can also set the position of the text in
console

18.  Internal Comments
◦ C# uses traditional C-type single-line(//…) and
Multiline (/*…………..*/)
 XML Documentation
◦ All XML comments begin with three forward slashes (///).
The first two slashes signify a comment and tell the
compiler to ignore the text that follows. The third slash
tells the parser that this is an XML comment and should be
handled appropriately.
◦ Ex:
/// <summary>
///
/// </summary>
/// <param name="strFilePath"></param>

19.  The tags recognized by the compiler
<c> The text you would like to indicate as code
<code> Marks multiple lines as code
<example> Marks up a code Example
<include> Includes comments from another documentation
file
<list> Inserts a list into the documentation
<param> Marks up a method parameter
<value> Describes a property
<summary> Provides a short summary of a type or member

20.  C# also includes a number of commands that are known as
preprocessor directives.
 These commands never actually get translated to any
commands in your executable code, but instead they affect
aspects of compilation process.

21. #define Tells the compiler that a symbol with the given name exists.
#undef Removes the definition of a symbol.
#if, #elif, These directives inform the compiler whether to compile
#else and a block of code
#endif
#warning These will respectively cause a warning or an error to be
and #error raised when the compiler encounters them.
#region and These are used to indicate that a certain block of code is
#endregion to be treated as a single block
#line This can be used to alter the filename and line number
information that is output by the compiler in warning or
error messages
#pragma This can suppress or restore specific compiler warnings.

22.  Identifiers
◦ Identifiers are names you given to variables and
user-defined types.
 Rules for Identifiers
◦ They must begin with a letter or underscore,
although they can contain numeric characteristics
◦ You can’t use c# keywords as identifiers