C01 - The C# Programming Language
-
The language
- The language the computers follow: 0's and 1's and the need of give instructions intelligible by human: source code in text files.
- [human]->source code->[compiler]->machine language
- every language has its purpose
- low level, high level
- C#
- general-purpose programming language (desktop apps, server-side, etc)
- it's balanced between:
- ease of use (Java is easier)
- power (C++ is more powerful)
- The language the computers follow: 0's and 1's and the need of give instructions intelligible by human: source code in text files.
-
.NET Framework
- the language platform
- two parts
- Common Language Runtime (CLR): a virtual machine, which actually executes the code
- [human]->source code->[C# compiler]->Common Intermediate Language CIL or IL in .exe or .dll->[CLR compiler using JIT]->binary machine language->[machine]->executing tasks
- IL Disassambler to open the CIL code #chapter40
- the Base Class and Framework Class Libraries (BCL, FCL)
- Massive library of code ready to be used
- Common Language Runtime (CLR): a virtual machine, which actually executes the code
-
C# and .NET
- first released in 2002 C#1
- .NET 4.6+Visual Studio 2015+C#6.0
C02 - Installing Visual Studio
- Visual Studio 2015 Community downloaded and installed. Required about (6h+10h) and 8GB of free space.
- On Lubuntu I installed MonoDevelop (mono+monodevelop packages) and Visual Studio Code (there is an ubuntu apt package, mono required to finish installation).
- First use of VS
- Using my personal MS account
- Started VS and skipped the Team Services
- To use dark IDE theme for «Visual C#»
C03 - Hello World: Your First C# Program
- Adding a new C# "Console Application" project to E:\workspaces\CSharpProjects\ch003
- .cs extensions for C# source code!!!
- Main code in Program.cs
- Some terms
- Project: collection of source code and resource files, and other additional information for the compiler to build the project
- Assembly: it's the project already compiled (.exe for process assembly or .dll for library assembly) Solution: combine multiple projects together to accomplish a task or form a complete program. It has information on how the different projects should be connected to each other.
- Explanation of the source code
- keyword using: to get libraries which are available to be used (details in #chapter26)
- {} to group code and its possible name with keywords namespace, class and method's signature
- relation of membership and hierarchy. Main method is member of class
Program
andProgram
is member of namespaceHelloWorld
.
- relation of membership and hierarchy. Main method is member of class
C04 - Comments
- Clarifying communication for yourself and other programmers.
- XML Documentation Comments, introduced in #chapter15, automatically populated by the IDE on typing three slashes before a group of code.
- Best comments:
- timely entered: just after the code or idea is completed.
- that adds value: dedicated to explain WHY we did the code instead of something else.
- that explains at least each section of related code.
- The code is the best comment, make it readable and understandable.
C05 - Variables
- Type, name and value to be used and operated
- Copying variables: it doesn't affect the original variable's value.
- Referring a variable: it happens using arrays. Look at #chapter16
- The «type system»
- a byte to get 256 different states of 0s and 1s or representation of numbers
- The importance of good variable names. Follow the seven rules.
C06 - The C# Type System
- Numeric (signed and unsigned)
- Integral
- char, (s)byte, (u)short, (u)int, (u)long
- Floating point
- float and double
- decimal
- Integral
- bool
- string
- Other types
C07 - Basic Math
- Operations and operands and operators
- binary operators
- unary operators
- ternary operator (look at #chapter10, it's
<boolean operand>?<operand if true>:<operand if false>;
)
C08 - User Input
- Need of get data from user.
- Need of convert from text input to numeric.
- Need to scape characters.
C09 - More Math
-
Typecasting or casting
- Implicit casting
- narrower type to a wider type
- Explicit casting
- Implicit casting
-
Division by zero
- Exception on using integral types
- Infinity on using floating point types
-
Other values: NaN for floating points, depending on the operation
-
Overflow and underflow after operations and using explicit casting with data loss
C10 - Decision Making
- Interesting introduction to conditionals
- Interesting learnable example, using always " because ' is only for characters:
Console.WriteLine($"The result is {theResult:0.0000}, and the sign is {((theSign == 0) ? "positive" : "negative" )}." );
C11 - Switch Statements
- No surprises: bool, string and integral types, with the exception on that break is strictly required, which is different from C++ and Java.
C12 - Looping
Interesting challenge:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PrintAPyramid {
class Program {
static void Main( string[] args) {
// 1,3,5,7,9
//int limit = 0;
for ( int row=0; row < 5; row++) {
for ( int column=0; column <= 3-row; column++) {
Console.Write( " ");
}
// row:=2*row+1
//switch (row) {
// case 0:
// limit = 1;
// break;
// case 1:
// limit = 3;
// break;
// case 2:
// limit = 5;
// break;
// case 3:
// limit = 7;
// break;
// case 4:
// limit = 9;
// break;
//}
for ( int column=0; column<2*row+1; column++) {
Console.Write( "*");
}
Console.WriteLine();
}
Console.ReadKey();
}
}
}
C13 - Arrays
- Declare arrays vs create arrays
- Ability to create multi-dimensional arrays like int[,] grid= new int [5,4];
- Ability to iterate arrays with foreach keyword, which is better to be used with implementations of IEnumerable interface.
- Usage of new is required. No delete keyword.
// interesting declaration of multiple dimensions
int[,] grid= new int[5,4];
for( int i = 0; i < 5; i++) {
for( int j = 0; j < 4; j++) {
grid[i, j] = i * j;
}
}
// access to the multi-dimensional array
for( int row = 0; row < grid.GetLength(0); row++) {
for( int column = 0; column < grid.GetLength(1); column++) {
Console.WriteLine( $"grid[{row}, {column}]: {grid[row,column]}");
}
}
Output:
grid[0,0]: 0
grid[0,1]: 0
grid[0,2]: 0
grid[0,3]: 0
grid[1,0]: 0
grid[1,1]: 1
grid[1,2]: 2
grid[1,3]: 3
grid[2,0]: 0
grid[2,1]: 2
grid[2,2]: 4
grid[2,3]: 6
grid[3,0]: 0
grid[3,1]: 3
grid[3,2]: 6
grid[3,3]: 9
grid[4,0]: 0
grid[4,1]: 4
grid[4,2]: 8
grid[4,3]: 12
C14 - Enumerations
- Brief introduction to "dot operator"
- No surprises but the interpolation interpretation of an enum value is its label.
public enum Months {
January,
February,
March,
April,
May,
June,
July,
August,
September,
November,
December
};
C15 - Methods
- No surprises, but the mention of the ability to have up to 65,500 parameters in a method.
- The
///
comments are immediately displayed by IntelliSense. - There it comes an explanation of recursion on pages 100-101 <3.
C16 - Value and Reference Types
- Program's memory
- Stack
- Pointer to the current state of execution.
- For method's frames, containing local variables including parameters in a single method invocation's frame.
- Heap
- Dedicated to storing data.
- Stack
- In a multi-threaded application, each thread has its own stack but share the heap with the others (#chapter37).
- Garbage collector
- In charge of managing the heap automatically
- This is an environment with managed heap. Managed by the CLR.
- This is the reason C# doesn't provide pointers but references. The references are included in the CLR's heap management.
- In charge of managing the heap automatically
- Value Types and Reference Types
- The key difference between them: «when you have a variable that is a value type, the actual contents of that variable live where the variable lives. With a reference type, the contents of the variable live on the heap, and the variable itself contains only a reference to the actual content.»
- The reference type allow nulls.
- The semantic of the type
- Value type semantic
- Data of the value inside of a variable
- On copy: the value (data) is copied
- Reference type semantic
- Reference to a location in the heap where the data are stored
- On copy: the reference is copied
- Value type semantic
Interesting on string class, it seems it's thread-safe, every "modification" makes a new instance, i.e., another referenced object.
static void Main( string[] args) {
string aString = "one value";
Console.WriteLine( $"the value is: {aString}" );
SecondMethod(aString);
Console.WriteLine( $"the value is: {aString}" );
Console.ReadKey();
}
static void SecondMethod( string arg) {
arg=arg.Insert(arg.Length, "_tail"); // this makes arg to point another string in the heap
Console.WriteLine( $"the value is: {arg}" );
}
C17 - Classes and Objects
- A way to structure code mimicking the way the real world works. It breaks it down into manageable pieces and presents it in an intuitive way for programmers to work with.
- Terminology
- Classes. they all are reference types.
- Objects or instances of a class
C26 - Namespace and using directives: #chapter26
- For the sake of code reuse
- namespace: identifies a set of related source code's names. A package of related code.
- using: brings a namespace to be used in the source code
C37 - Threads
- In a multi-threaded application, each thread has its own stack but share the heap with the others (referred by #chapter16).
C40 - C# and the .NET Framework: #chapter40
- On binary, assembly, high-level languages and compiling
- On virtual machines and the CLR
- Advantages of CLR
- Memory management
- Security
- Multiple high level languages
- Drawbacks of virtual machines
- Performance
- Bad for low-level coding
- Visible source code, code-obfuscation techniques needed
- The .NET Framework: BCL and FCL Class Libraries
- Very large collection of previously built code and types. It's more massive than C++ and many other languages in terms of the standard library they come with.
- Its size is similar to Java's. BCL uses the System namespace.
- The FCL includes the BCL and other libraries related to broad functional areas like database access, GUI, etc.
- If you need to program a task you suspect somebody could build it before, it could be included in the FCL, so it's better you search for it before.
[finish]