Downloaded from git.ir
Hi! Thank you for taking my C# tutorial for beginners. Let me quickly give you an
overview of what you're going to learn and how I've structured this tutorial. In the
first section, I'm going to talk about fundamentals of C# and .NET.
one of the questions that a lot of beginners ask is what is the difference
between C# and .NET so I'm going to cover that I'm also going to talk
about CLR assemblies namespaces IL code and stuff like that then over the next
two sections I'm going to talk about types I'm going to talk about primitive
and non primitive types now at this point you still cannot write any C#
programs but I have designed a number of quizzes to help you reinforce what
you're going to learn then from Section four where I talk about control flow
you're going to start writing simple C# programs and from that section
onwards in every section you're going to learn something new about C# and
you're going to write more interesting programs and finally I'm going to
conclude this course with a section on debugging so I'm going to show you some
of the tools we have so when you have bugs in your code you know how to find
them and get rid of them I'm also going to talk about some good program
practices that help you write better and more reliable code so we have a lot to
cover and let's get started okay so this is the very first section of this course
in this section I'm going to start by teaching you the very basics of C#
one of the questions that a lot of beginners ask is what is the difference
between C# and net so that's the first thing I'm going to answer here
next I'm going to talk about CLR or common language runtime which is the
runtime environment for .NET applications next I'm going to talk
about the architecture of .NET applications and as part of this I'm
going to introduce you to concepts such as classes namespaces and assemblies and
finally I will show you all these concepts in action I'm going to
introduce you to the very basics of visual studio and write a very simple
C# application so you can see classes namespaces and methods in action
I hope you enjoyed this section and let's get started
okay what is darknet framework and how is it different from C# some
developers who are absolutely new to C# don't know the difference so in
this lecture I'm going to talk a little bit about C# and .NET framework
C# is a programming language .NET is a framework for building applications
on the windows .NET framework is not limited to C# there are different
languages that can target that framework and build applications using that
framework examples are F sharp or vb.net okay now but what exactly is .NET
framework Dartmouth framework consists of two components one is called CLR or
common language runtime and the other is a class library for building
applications in the next lecture we'll talk about CLR in more detail
okay before we understand what CLR is and why we need it let me explain a
little bit about the history of C# before C# we had two languages in
the C family the C language and C++ with either of these languages when we
compiled our application the compiler translated our code into the native code
for the machine on which it was running which means if I wrote an application in
C++ on a Windows machine with 8086 processor architecture the compiler
would translate my code into the native code for that machine that is a Windows
machine with an 8086 processor now we only have different hardware's and we
have different operating systems so if I took the application that compile the
application on the computer with a different architecture that would not
run so when Microsoft was designing the C# language and the .NET
framework they came up with an idea that they borrowed from the Java community in
Java when you compile your code it's not translated directly into the machine
code it's translated into an intermediate language called bytecode
and we have the exact same concept in C# so when you compile your C#
code the result is what we call IL or intermediate language code is
independent of the computer on which it's running now we need something that
would translate that il code into the native code or the machine that is
running the application and that is the job of CLR or common language runtime so
CLR is essentially an application that is sitting in the memory whose job is to
translate the il code into the machine code and this process is called
just-in-time compilation or JIT so with this architecture you can write
an application in C# and you don't have to worry about compiling that into
the native code for different machines as long as a machine has CLR that can
run your application
okay now let's learn about the architecture of .NET applications at a
very high level when you build an application with C# your
application consists of building blocks called classes these classes collaborate
with each other at runtime and as a result the application provides some
functionality now what is a class a class is a container that has some data
which is also called attributes and functions which is also called methods
functions or methods have behavior they execute code they do things for us data
represents the state of the application let me use an example think of a car the
car has some attributes like its make its model its color these are the
attributes of a car a car also has some functions we can start it or we can move
it so you can think of a car as a class in a real world application we have tens
hundreds or even thousands of classes each class responsible for a piece of
functionality an example of that is classes that are responsible for getting
the data from the user process the data and display something to the user
now as the number of classes in an application grows we need a way to
organize these classes that's where we use a namespace so a namespace is a
container for related classes for example in .NET framework we have
namespaces each containing tens of related classes we have namespaces for
working with data like databases we also have namespaces for working with
graphics and images we have namespaces for working with security now in real
world application as these namespaces grow we need a different way of
partitioning an application and that's where we use an assembly and assembly is
a container for related namespaces physically
it's a file on the disk which can either be an executable or a DLL which stands
for dynamically linked library so when you compile an application the compiler
builds one or more assemblies depending on how you partition your code in the
next lecture we're going to write a very simple structure application and you're
going to see all these concepts in action
okay in this video we're going to have a quick tour of visual studio and build a
very simple C# application so here I've got Visual Studio open let's go to
file new project
okay in this dialogue on the left side we've got a section called templates and
here you see the kind of applications we can build with C#
so as you see in the list we can build desktop applications web applications
apps for cloud mobile services workflows and various kind of things but in this
course and the subsequent parts of this course we're just going to focus on
console applications a console application is a very simple application
that does not have a graphical user interface and it's a great learning tool
for learning a new language so we're not going to be distracted by various
complexities of larger applications so on the left side select windows and on
the right side select console application
then give a name to your project so let's call it hello world which is a
common tradition when learning a new language and specify a location you can
put it wherever you want I know this concept of solution in Visual Studio we
have this concept of solution which can have one or more projects with a very
simple application you have only one solution and one project but as your
application grows you add more projects each responsible for something different
but now we don't have to worry about it now click OK
alright let's see what's happening here some developers get a little bit
intimidated the first time they open visual studio and that's very enough
because there are so many menus and panels here that is a bit confusing but
let me tell you something 90% of the time you're going to use only
10% of these or even less so don't worry about all these menus here you don't
need to use all of them at all times 90% of the time all you need is the code
editor here sometimes you need the solution Explorer
in fact I personally hardly ever use solution Explorer because I do
everything with my keyboard and if you watch my course double your coding speed
you will see that everything is possible with keyboard so you don't need these
panels here you don't need to grab your mouse and navigate around you don't
really need this stuff also none of the stuff on the toolbar
are ever required don't worry about it everything you can do with your keyboard
alright now let's take a look at this first to char program so we created a
console application and on the right side you see the solution Explorer panel
in case you don't see that go to view and select solution Explorer
top you see we have a solution which has only one project under that we've got
the project called hello world look at these four items here properties expand
that we have a file here called assembly info this is the identification or the
assembly that will be produced as a result of compiling this application so
when we compile the console application we're going to get an executable and
that's an assembly that assembly has an identification look at these attributes
here like the title description which is currently not set company product
copyright trademark culture a grade you know various kind of things like even
version so these are all part of assembly identification or assembly
manifest in most cases you don't have to worry about it but if you want to create
an assembly and you want to distribute it send to other people then you may
want to come here and give you the proper name and a proper version so for
now we don't have to worry about it
on the references you see any assemblies that this project is referencing to do
its job when you create a project with visual studio by default it as a
reference to a bunch of assemblies that you'll see here these are all part of
.NET framework so at a minimum Visual Studio assumes you're going to use
classes in system assembly or system the data to work with databases and so on
you may not necessarily use all these assemblies in your project but that's
just part of the template
config' is an XML where we store the configuration for this application
sometimes you may want to store connection strings to the database or
you may want to have some settings about your application all of them will end up
here and finally you see program dot C s
which is where we are going to start writing code all right let's see what's
happening here so in this file program that C S on the
top you see a bunch of using statements what is this all about
well our project is called hello world so by default Visual Studio creates a
namespace called hello world when we write code in this namespace we have
access to any classes defined in this namespace so if you want to use a class
that is defined in a different namespace we need to import it in our code file
and that's why we use the using statement so by default Visual Studio as
these five using statements system is a namespace in .NET framework and that's
where we have all these basic utility classes and primitive types there
system that collections that generic is used to work with lists collections and
so on system that link is used to work with
data and it's a comprehensive topic that I have covered in my C# Advanced
Course system the text is used to work with tags and coding and stuff like that
and finally system the threading is used to build multi-threaded applications in
this video we're going to create a very simple application and we're not going
to use any of these for namespaces here so we're just going to use system for
now I'll leave them there and then I will show you how to clean them up all
right so here's our namespace and insight namespace by default we have a
class called program so every console application you create with Visual
Studio has a class called program inside program by default we have a method or a
function called main and that's the entry point to the application so when
you run your application CLR execute the code inside main method and that's where
everything kicks off this method is declared as static and that's something
I'm going to cover later in the next section methods have input and output so
what goes inside parenthesis is the input to the method which we call
parameter or argument note that parameters are optional but in this case
in the default template the main method has a parameter called args which is of
type string array we're going to learn about string array in the next section
what you see before the method name is the return type or the output of the
method void in C# means nothing that means this method does not return
any value it just contains some code that's it
also note that C# is a case sensitive language so this main has to
be with capital M otherwise CLR is not going to find this method as the entry
point of the application okay and one last thing is note these curly braces so
where we have a block of code we need to surround it with curly braces so that is
applicable for methods for classes and for namespaces
alright now let's write a very simple C# program so let's go here we have
a class called console which is used to read data from console or write data to
it it has a bunch of methods access this method using the dot
notation and here you see various members of this
class methods are indicated by a purple cube so beep is used to play a beep
sound or clear is used to clear the console we're going to use the right
line method this method can optionally take a
parameter so I'm going to pass a string here hello world just that I note that
statements in C# terminate with a semicolon as you see here
now take a look at using system on the top
do you see that it's highlighted whereas the others are grayed out the reason for
that is in this file we are using a class called console which is defined in
the system namespace that's why that using statement is active we are not
using any classes defined in other namespaces and that's why they're grayed
out
so we can get rid of them to make our code cleaner we can either delete each
one by ctrl X like that or if you're using resharper you can get rid of all
of them by pressing Alt + Enter here and
selecting the first option which is remove unused directives in file so it's
faster now let's run the application with ctrl + f5
so this window that you see here this black window is what we call console and
that's why this kind of project is called console application
you okay that's it for this lecture from
this point in every lecture we're going to learn something new about C# and
we can write more interesting and more complex programs I hope you enjoyed this
lecture and thank you for watching well hello it's mush here your C#
instructor I just wanted to quickly let you know that this video you've been
watching is actually part of my C# basics course on udemy in this course I
walk you through all the core concepts of C# in a step-by-step fashion
plus you get access to exercises cheat sheets and a discussion board to ask
your questions in case you're interested you can get this course with a discount
using the link in the video description and if not that's perfectly fine
continue watching as the next section is coming up okay this section is going to
be the first step in your journey to learn C# so I'm going to introduce
you to variables and constants I'm going to talk about various data types and
type conversion I'm going to talk about scope and overflowing and finally I'm
going to talk about various operators we have in C# so let's get started
okay we are going to start our journey by learning about variables and
constants
a variable is a name that we give to a storage location in memory where we can
store a value any constant in an immutable value that is a value that we
know at compile time and that value cannot change throughout the life of the
application why do we use constants the reason for that is to create safety in
our application imagine you're creating an application that involves some
mathematical computation around circles we have this number called P which is
3.14 and we use that to calculate the area of a circle that number should
always be the same we don't want to accidentally change that in our program
if you accidently change that everything is going to blow up in terms of the
results the program produces so we declare that number as a constant
and this way we create safety in our application in C# to declare a
variable we start with the type followed by an identifier and finally semicolon
here ain't represent integer which is a number between minus 2 billion and plus
2 billion later in this video I will show you all the primitive types that
you need to know also note that C# is a case
sensitive language which means in this case these two identifiers are different
one has lowercase n and 1 has uppercase n
when declaring a variable we can optionally assign it the value like what
you see here you don't have to but there is one thing you need to know about
variables and that is you cannot use a variable unless you initialize it so
let's say if I declare this int number here and I decide to display it on the
console my application will not become part I have to assign it a value before
I can use it before I can read it I will show you that later when we jump to
coding to declare constant we start with the
keyword cunt next we have the datatype and an identifier and here we have to
initialize it with some value we cannot define a constant without setting its
value
there are a few things you need to know about identifiers first one is that an
identifier cannot start with a number so you cannot have an identifier like the
one you see here instead you need to replace one with the word one
so an identifier cannot include whitespace so you cannot have an
identifier like first space name it has to be one word an identifier cannot be a
reserved keyword like int that you saw earlier if you are desperate to use a
word that coincidentally clashes with one of the C# keywords you can
perfect that with the add sign and finally as a recommendation always
use meaningful names for example avoid a name like f n instead use first name
this way your code will be more readable or maintainable and cleaner and
everybody will understand that
in terms of naming convention here are three popular naming conventions that
have been around in the C language family
we've got camelcase Pascal case and Hungarian notation with camelcase as you
see I have bolded here the first letter of the first word is lowercase and the
first letter of every word after has to be uppercase with Pascal case the first
letter of every word has to be uppercase with Hungarian notation we prefix the
name of a variable with the datatype it uses so here str represents a string
Hungarian notation is not used in C# and I have noticed programmers
coming from C or C++ background use that in their code if you're one of them I
highly recommend you not to use Hungarian notation because C#
developers are not used to that and they don't like to see Hungarian notation in
the code it makes your code look a little bit ugly
so in C# to name your local variables use camel case so as you see
here the first letter of the first word is lowercase and if we had more words
here in the identifier the first letter of every word had to be uppercase four
constants use Pascal case so here you see I've got a constant here constant
integer and the first letter of every word is uppercase here is the list of
most commonly used primitive types in C# in fact the actual list is
slightly bigger than this but I deliberately decided not to include
those data types because they're hardly ever used in fact they are there for
interoperability with other languages I personally over the past 12 years of me
coding in C# I've hardly ever used them in fact never so I decided not to
confuse you with too much details that you don't need in the next slide I've
got a link here in case you want to learn about the other primitive types so
let's take a look at the table here on the left side I have divided these
datatypes into four categories integral numbers real numbers character and
boolean this column shows the C# data times
and these are C# keywords note that C# keywords are always lowercase
each of these C# keywords or C sharp types maps to a type in .NET
framework which is displayed in this column
so these types are part of the.net framework and when you compile your
application the compiler internally would translate the C# keyword you
use here two equivalent .NET type the third column here shows the number
of bytes each data type uses and I have listed these data types from the
smallest to the largest in each category so in the category of integral numbers
you see byte is the smallest it takes only one byte whereas long is the
largest and it takes 8 bytes the more bytes we have the more storage we have
and we can store larger numbers you don't really have to memorize the range
of each data type but remember white can store a value between 0 to 255 short can
store a value between minus 32,000 to plus 32,000 integer can store a value
between minus 2 billion to Plus 2 billion and long is even bigger than
that in terms of real numbers we have three
data types float double and decimal float maps to the single type in that
framework and it takes four bytes and as you see it can store a very large number
double is twice as big so it uses eight bytes and decimal uses sixteen bytes the
more precision you need the bigger data type you use we also have character
which is represented by char keyword and it's two bytes so characters in C#
are unicode and finally we have bull which represents boolean which can be
either true or false in case you want to learn more about the
other data types that I told you they're not really used you can simply go to
Google and search for C# built-in types and the first page is the MSDN
page that lists all the primitive types in C#
and most of these data types are pretty straightforward but there is something
tricky about real numbers in this table I have listed the data types we have for
real numbers load double and decimal I've highlighted double because that's
the default data type used by a C# compiler when you're using real numbers
so if you want to declare a float you need to explicitly tell the compiler to
treat the number you have as a float here is an example I've declared a float
call it number as I need one point two here I have added the suffix F and that
is to tell the compiler to trade this number as a float if I didn't have this
F here compiler would think one point two is a double because double is the
default data type for real numbers and of course I cannot assign a double
number into a float so the program would not compile same applies to decimals so
if you want to declare a decimal you need to add the suffix M at the end of
the number in C# we also have a few other
types which are not considered primitive types and they are string array enum and
class we'll learn more about them throughout this course okay that's it
for this lecture in the next lecture we're going to talk about the concept of
overflowing I hope you enjoyed this lecture and thank you for watching
okay now let's talk about the concept of overflowing here I've declared a
variable of type byte cut the number and assign it to 255 as I told you earlier
in the slide 255 is the largest value you can store
in a byte now in the next line I'm increasing the value of number by one
and trying to store 256 in the number but if you compile the application and
display number on the console you will see zero and this is what we call
overflowing so we have exceeded the boundary of the byte data type in
C# by default we don't have overflow checking which means we can
modify the value of a variable at runtime and if we go beyond the boundary
of its underlying data type we will get overflow now sometimes this is not
desirable in your application you want to stop overflowing if that's the case
you need to use the check keyword so here is how it works we have the checked
keyword followed by curly braces which indicate the code block and inside that
block we have the variable declaration and any kind of arithmetic operations
with this code overflow will not happen at runtime instead an exception will be
thrown and the program will crash unless you handle the exception the topic of
exceptions is an advanced topic and I have covered it in my C# advanced
course for now all I want you to know is that if you use the check keyword
overflow will not happen and instead the program will throw an exception now do
we really need that in reality honestly I have never ever ever came across this
situation because if I was concerned that in this case my number variable
would overflow I would just simply use the short data type instead of byte but
I decided to include the concept of overflowing because I wanted my
sous-chef course to be comprehensive so just be aware of that in case you hear
about overflowing somewhere but you're probably not going to use that in the
real world in the next lecture we're going to talk about the concept of scope
okay let's talk about the concept of scope what is the scope scope is where a
variable or a constant as meaning and is accessible take a look at this block of
code here as you know a block is indicated by curly braces here we have
three blocks of code here's one here is another and here is the last one inside
the first block I've got a variable called a an a is accessible anywhere
inside this block or any of these child blocks
if I go out of this block and try to access a the program will not compile
the same rule applies to other variables so let's take a look at this block here
B is meaningful anywhere inside this block or any of its children if I go
outside this block and try to access B I'm going to get a compile time error
okay I think that's enough theory for now let's open up visual studio and do
some coding
okay let's start by declaring a variable of type byte and call it number
now we want to display it on the console so as you remember from the last lecture
we type console dot write line and put the variable here note that as I was
typing console dot write line my resharper plugin automatically added
this using statement on the top system is a namespace and console is a class
that is defined in the system namespace so in order to use the console class we
need that declaration here on the top if you're not using resharper you have
to go here and manually type using system semicolon okay now take a look at
this number here it has a red underline and if we put the mouse cursor here it
says local variable number might not be initialized before accessing if you
remember from the slides I told you in C# before you can access a variable
you need to set it you need to initialize it and that's the reason here
we have the red underline we cannot display the number on the console before
initializing that so if I try to compile the application we're going to get an
error to compile an application you press ctrl shift + B and here is the
error list use of unassigned local variable number we can solve this
problem by initializing number like setting it to 2 for example and you see
the red underline is gone we can compile again control-shift be
build succeeded take a look here okay now we can run the application by
pressing ctrl + f5 okay so we got two on the console now let's extend this
example and declare a few more variables define an integer int count equals 10
and a float float say total price equals 20 $95 now note this red underlined here
let's find out what's happening here so I put the mouse cursor here it says
cannot convert source type double to target type float if you remember from
the slides I told you by default the sea-shore compiler traits
real numbers like this one here as double whereas we are declaring a float
so here we need to explicitly tell the C# compiler to treat this real
number as a float and we can do that by appending an F at the end
so the error is gone let's take your character so char character equals a
note that in C# we enclose characters by single quote like here we
can also declare a string string is not one of the primitive types and have
covered it in a separate lecture in this course but for now let me show you how
to declare a string which is type string give it a name first name equals mosh
note that with strings we enclose them in double quote so that's one of the
differences between strings and characters
and finally let's declare a bull bull is working equals true so with bulls we can
either set them to true or false both true and false our keywords as you can
see they're indicated by the blue color here and they're lowercase so everything
you see here that is blue is a keyword like static void string class name space
and all these data types here now let's display these variables on the
console so let me show you a trick instead of writing constant the right
line we can do a shortcut this is what we call a code snippet so we type CW
that is short for console.writeline and then press tab and Visual Studio
automatically converts that to console the right line there are various code
snippets that help you write code faster and I will try to point them out
throughout this course so let's display count now another one totalprice
and note that i can just type t oh and here is what we call intellisense it's
visual studios auto completion mechanism you don't have to type the full name of
a type or a variable as long as the intellisense detects tab and is
highlighted here like total price you can simply press tab and there you go
visual studio automatically completes that for us let's display the character
same here I just press tab again I type only a few characters it can press tab
or enter and finally is working we run the application by ctrl + f5
so we got all these values on the console
okay now let me show you something else in C# we have a keyword called var
which makes variable declarations easier for example here instead of explicitly
specifying the datatype for each of these here I can simply type var
and I let the C# compiler detect the datatype for this variable here so
let me replace all of this with var okay now if we hover the mouse over the VAR
keyword we can see the underlying data type in
this case is system that boolean which is the data type which maps to C#
pull keyword how about this one that's a string
and this one is a character and this one is system that single which maps to
float in C# and in the case of count it's in 32 which is integer and
same for a number so the tricky thing here is by default C# treats
integral numbers as integer and when you use the VAR keyword it assumes that it's
an integer if you really want to go for a byte then you have to explicitly
specify it as byte here but tell you from experience it's safe to use integer
in most cases in fact if you look at the classes in the.net framework in most
cases integer is the data type used for representing integral numbers okay I
revert this back now I show you something else so let's
take a look at this one here so it's a char which is a character
I can put the mouse cursor here and press control and then click
that opens the object browser window take a look here it's object browser and
it's a way to look at the various classes in your project or in the.net
framework in this case because I did a ctrl click on the char or VAR keyword
this is what we got here so char is highlighted in the object
browser on the right side you see all the
members of the chart type so these purple ones are functions or
methods if you scroll down here you see two fields here min value and Max value
we'll explore them shortly and note that here is the Declaration of Char Char is
a structure we will cover structures later in this course
and note that it's a member of system namespace
it can click system and that shows the system namespace as well as all the
types defined in the system namespace so these are part of the.net framework ok
let's close this for now let's explore another example so I'm going to get rid
of all the code here we can simply press control X on each line and that deletes
all these lines here ok let's do a console the right line so CW tab this
time I pass a string here I specify two placeholders
and finally supply a couple of arguments
okay let's see what's going on here so here what we have is called a format
string it's a kind of string that can be used as some kind of template so at
runtime what we have here indicated by curly braces and 0 as the argument will
be replaced by the value we pass here so 0 represents the first argument after
this format string and 1 represents the second argument after this format string
in this case bited max value so let's run this application
we got 0 and 255 and that's the range that you can store in a byte
we can do the same with a float so CW tap a format string float mean value
float Max value run the application
so this is the range we can store with a float it's a huge number that is
displayed using the scientific notation
okay now let's take a look at constants so I get rid of these two
lines here control X control X we define a constant with the Const keyword Const
float P 3.14 and we have to put F at the end because it's a float now because we
declared P as a constant here I cannot change it in my program so I cannot go
here and say P equals 1 the compiler is not happy and that's why we see that red
underline here if you hover the mouse here it says
read only local constant cannot be used as an assignment target it's a little
weird expression to understand but basically the intention of using
constants is to have some kind of safety in your program so if there are values
that should not be changed throughout your program you define them as constant
and this way you want to accidentally modify their values well if you made it
this far you seem to be very enthusiastic about learning C# and
I highly recommend you to take my C sharp basics course using the link in
the video description this way you can learn all the core concepts in a
structured way and you don't have to waste time jumping from one free
tutorial to another you can see that currently this course has over 5,000
students with over 400 five-star reviews plus it comes with a 30-day money-back
guarantee so if you're not satisfied you can ask udemy for a full refund within
30 days and you get all your money back no questions asked again you can get
this course using the link in the video description I hope to see you in the
course
in this video I'm going to talk about various kinds of type conversion in
C# we have implicit type conversion explicit type conversion which is also
called casting and we also have conversion between non compatible types
here is an example of implicit type conversion a blight as you know takes
only one byte of memory and an integer takes four bytes so we can easily copy a
byte to an integer what happens at runtime is let's take a
look at this slide so here's the binary representation of our B variable here so
one is represented as seven bits of zero and one bit of one when we copy a byte
to an integer what the runtime does is it prefixes that value with a bunch of
zeros to fill the four bytes there is no data loss
in situations like that when the compiler is 100% sure that the types are
compatible and no data loss will happen values can be converted to a different
type implicitly here is another example of implicit type
conversion so we have an integer set it to one and we copy that to a float again
in this example no data loss will happen but let's take a look at this one here
we have declared an integer and we're trying to copy that to a byte
and integer is four bytes so when we convert that to a byte three bytes out
of four bytes will be gone and there is a chance for data loss
now data loss doesn't always happen it only happens if the value restored in
the integer is beyond the capacity of a byte in this example one can be stored
in a byte so no data loss will happen but if we
had let's say 300 here we cannot store 300 in a byte so as a result of that
conversion data will be lost when the compiler knows that there is a chance
for data loss it doesn't allow implicit type conversion and you need to
explicitly tell the compiler that you're aware of the data loss and you still
want to go ahead with the conversion in situations like that what we do is we
prefix the variable with the target type so here I'm trying to convert I to a
byte this is what we call as casting
here is another example so we have a float set to 1.0 and if we try to
convert that to an integer the compiler would complain I will show you that
later in the coding demo so we need to tell the compiler that we are aware of
the data loss and we still want to convert F which is a float to an integer
so we cast it like here sometimes we are working with types that
are not compatible but you still need to convert them for example we might have a
number represented as a string as you see here and we need to convert it to an
integer in situations like that because string and int are not compatible they
cannot use explicit casting so we need a different mechanism for
converting a string to a number in situations like that we need to use
the convert class or use the parse method
so convert class is part of .NET framework and is defined in the system
namespace of methods for converting various types
to other types and they all start with two in this case we're trying to convert
s which is a string to an int 32 in 32 as you know is a .NET framework type
which maps to a sushar p-- integer type remember a blight is one byte short is
two bytes and integer is 4 bytes and long is eight bytes you probably know
that each byte has 8 bits so an integer which has four bytes times eight bits
ends up being 32 bits that's why it's called two in 32 and in 16 which
represents 16 bits equals to short which is 2 bytes we also have this parse
method here all the primitive types that I explained in the last lecture
like integer long float boolean they all have this parse method and the parsh
method takes a string and tries to convert that to the target type in this
case an integer here are some of the methods that you
can find in the convert class to byte which converts the given value to a byte
2 in 16 to convert the given value to a short 2 in 32 to convert the given value
to an integer and to n64 to convert the given value to a long okay in a theory
let's jump into code and see all this concept in action
okay let's say implicit type conversion in action first I declare a bite call it
B and set it to 1 now I declare an integer and set it to
be again to recap a byte is only one byte and an integer is 4 bytes so we can
copy b2i without data loss and as you see there is no compile time error here
let's put on the console so console dot write line and we pass I here note that
as I typed consult the right line my resharper plugin automatically added
this using system statement on the top again if you don't have resharper you
need to go manually add this statement here we run the application by ctrl + f5
so we got on the console
now let's reverse this and see what happens so I'm going to get rid of this
code here control X control X control X first I declare an integer set it to one
then I declare a byte and try to copy I to B we immediately got this red
underline here if you hover the mouse here the tooltip says cannot convert
source type int to target type byte sometimes this error might be in a
different file which is not open in Visual Studio here so you may see the
error when compiling the application let's simulate that so I compile this
application by ctrl shift and B which stands for build so here's the error
cannot implicitly convert type int to byte an explicit conversion exists are
you missing a caste so now you understand the concept of implicit
versus explicit type conversion so what we need to do here is to do a cast so we
casted integer to a byte now in this case no data loss will happen because
the value is small enough to be stored in one bite let's put B on the console
console by right line B we run the application
so everything is good but let's see what happens if we said I - let's say
thousand we cannot store the number thousand in a byte the maximum we can
store in a byte is 255 so if you run the application now
we got to 32 because some of the bits were lost and this is the reason that
C# compiler knows that there is a chance for data loss and it enforces you
to explicitly specify the cast sometimes you know that despite the differences in
data types there is no chance of data loss like in the last example where I
was set to 1 in those cases we can safely apply a cast okay now let's take
a look at non compatible types so let's clean up this code I start by declaring
a string let's call it number and set it to one two three four
recapping from the last lecture note that here I could declare this with the
VAR keyword and since our compiler automatically detects that this is a
string so number will be defined as a string and we can see that by hovering
the mouse here it says system that string
now let's say we want to convert that to a number
if I declare an integer like I I cannot cast that number to an integer because
they're not compatible let's take a look at the error cannot cast expression of
type string to type int so if you see that error that's the time when you need
to use the convert class
so we type in convert dot take a look at this method here - bite - char - in 16
in 32 and many other methods here so let's convert that to an integer which
is int 32 and pass number as an argument here now let's print out the I on the
console run application so I is 1 2 3 4 all good but let's see what happens if
instead I declare this as a byte and here we need to use convert dot 2 byte
and here we display B on the console a byte does not have enough storage to
store the value of 1234 so when we run the application now
the application crashed the cancel is here and here is the
exception exception is Dartmouth frameworks error reporting mechanism
it's an advanced topic and I have covered it in detail in my C#
Advanced Course but in this video I will briefly show you how to handle
exceptions so here it says unhandled exception the type of exception is
system that overflow exception which means we try to store a value that was
too large or too small for a byte so each exception or error as a type in
this case overflow exception and has a message value was either too large or
too small for an unsigned byte sometimes the exception messages are friendly
enough that are easy to understand sometimes they're a little bit tricky
and the best way to work out what is going wrong is to jump on Google and
search for the error and there's pretty much always a Stack Overflow page that
explains that now let's describe that let's see how to handle the exception
here happened during conversion of that
string to bite what we need to do here is to wrap these few statements with a
try-catch block let's see how it works
so I just typed try and press the enter and visual studio automatically
generated this block for me again this is what we call a code snippet let me
undo this I'll show you one more time so try see this try here in the
intellisense and this icon represents a code snippet so if I press enter or tab
you automatically get this code block so what I'm going to do now is to move this
code enter a try block and the catch block gets an exception by default
visual studio as this throw here don't worry about it just delete it again I
will explain it in detail in my sushar Advanced Course for now let's see what's
going on here so the code that you put inside the try block will be somehow
monitored and if an exception happens this block will be executed this
prevents your application from crashing the reason our application crashed
earlier was because we did not handle the exception so if you don't handle
exception the exception will be propagated to the .NET runtime and
that the run times mechanism is to stop your application and display the error
here we can handle the exception and that would prevent the exception from
being propagated to .NET runtime so instead we can display a friendly
message to the user saying for example console.writeline
the number could not be converted to a byte
now let's run the application again
see we got the firmly message and the application didn't crash
so what I want you to take away from this lecture is this
we're class works pretty well in most cases but in cases where the source type
cannot be converted to the target type there is a chance for exception and you
need to be aware of that and what you need to do is to wrap this block of code
with try-catch let's take a look at one more example before we finish this
lecture let's remove this and instead - drink
call it STR and set it to true we can use the convert class to convert that
value to a boolean so bull P equals convert that to boolean and we pass that
STR here
again in this example string and bull are not compatible and that's why we
cannot use explicit casting so here we are using the convert class we can
display B on the console
application so the true string was successfully
converted to a boolean value
that's pretty much it for this lecture before I finish I just need to emphasize
something here that throughout this course during early lectures you may see
me using some short variable names like P or STR here that's purely for
demonstration and keeping things simple and in building real-world applications
we should really avoid naming our variables ABC STR it's not really a good
practice the only exception is when we get to loops which you will see later in
this course in for loops we use counter variables and we call them I or J it's a
common convention now here we are just starting to learn C# and it's
really impossible for me to demonstrate building a real world application
because you're just covering their basics or alphabets I hope you enjoyed
this lecture and thank you for watching
okay we got two operators in C# we have five types of operators arithmetic
comparison assignment logical and bitwise let's take a closer look at each
of these operators we use arithmetic operators in computations where we are
working with numbers so as you see in this slide we have add subtract multiply
divide and remainder of division we also have two arithmetic operators called
increment and decrement which are a shortcut for adding one or subtracting
one from a variable so a plus plus is equivalent to a equals any plus one now
with this increment and decrement operator there are two ways you can
apply them you can use them as a postfix so in this example a is 1 and when we
apply the postfix increment operator first the value of a is assigned to B so
B is going to be 1 and then a is incremented by 1 so in this example
after the second line is executed a is going to be 2 and B is going to be 1 now
let's take a look at a different way of applying increment operator as a prefix
so in this example in the second line first a is incremented by 1 and then
it's assigned to B so after the second line both a and B are going to be 2 so
be aware of this difference ok next comparison operators so we got equal
which is indicated by double equal sign not equal greater than greater than or
equal to less than and less than or equal to now what I want you to pay
attention to in this list is that the testing for equality is accomplished by
double equal sign and that's different from a single equal which is the
assignment operator next assignment operators so the most commonly used is
the one with a seen the equal sign so here we set a 2/1
pretty basic now look at the next four types of assignment operators addition
assignment subtraction assignment multiplication assignment and division
assignment let's see how they work for example addition assignment a plus equal
3 means add 3 to a so it's equivalent to writing a equals a plus 3 and the same
rule applies to other 4 assignment operators logical operators are used in
boolean expressions which are often used in conditional statements will get two
conditional statements later in this course so a real-world example is where
you have a condition and you want to make sure that condition and another
condition both are true or maybe one of them is true so that's where you use a
logical operator in C# the logical end is indicated by double ampersand and
the logical or is implemented by double vertical line we also have the not
operator which is indicated by an exclamation mark and finally in here
we've got the bitwise operators bitwise operators are often used in low-level
programming like when working with windows api or in sockets or encryption
explanation of these is beyond the scope of this course but if you are interested
let me know and I write a blog post for you now what I want you to take away
here is that the bitwise End is indicated by a single ampersand whereas
the logical end which we use in conditional statements is indicated by
double ampersand same for bitwise or and logical or so remember the difference ok
enough theory let's flip over to visual studio and see all these concepts in
action
okay let's start with the arithmetic operators first so I define two
variables a equals 10 B equals 3 let's add them together and display the
results in the console
that's pretty easy right run the application so the result is 13 now
let's take a look at division so I replace the ad operator with division
you
the result is three the interesting thing here is because both a and B are
integers the result of the division ends up being an integer if you like a
floating-point number as the result of the division you need to cast both these
numbers to a float so like this now if you're on the application
the result is a floating-point number
now let's look at a more tricky example
let's say C's 3 B's 2 and a is 1 I want to show you the concept of operator
precedence
so if I type a plus B times C what do you expect the result to be from a
mathematical perspective B should be multiplied by C first which means two
times three equals six and then it should be added to one so the result
should be seven let's run the application
so C# behaves exactly as what we expected so multiply or division
operators have higher precedence than add or subtract if you'd like to change
the precedence you can do so by using parentheses so in this case if you would
like to have a and B added together first and then multiply it by C this is
how we would achieve that in this case the result will be 9
there you go
okay now let's take a look at comparison operators
so let's get rid of C here and instead see if a is greater than B very simple
example right
the result is false so what I want you to know here is the result of the
comparison expression is always a boolean value which is true or false we
can test for equality so double equal sign in this case a is not equal to B so
the result should be false
now let's see the not equal operator so simply have an exclamation mark here
followed by an equal sign in this case because a is not equal to B the result
should be true
okay now let me show you a more tricky example what do you expect here well
first this is the not operator which is applied on boolean values or boolean
expressions in this case this is a boolean expression and as you saw
earlier it was true because a is not equal to B so we apply the not operator
to that and the result ends up being false let's run the application
so we got files here but this code is not easy to understand or easy to read
because here we have two negatives one negative and two negative and for us
humans to negative is hard to comprehend two negatives always equal to one
positive so in your program if you end up in situations where you have two
negatives make sure to always inverse them with one positive so in that case I
can get rid of the first negative and convert the second negative to a
positive like that and we will get the same result which is false now let's
take a look at logical operators so I create another variable here VAR c
equals 3 I'm going to change that to C greater than B and C greater than a what
do you expect here as the result well C is greater than B so the result of that
expression is true also C is greater than a so the result of that expression
is true as well and here we have the end operator so true and true equals to true
let's run the application
there you go now let's make a tiny change here so this time because we know
C is not equal to a this expression evaluates to false true and false
results in false let's run the application
so we got false now let's see the effect of the or operator so I'm going to
replace the end with or which is double vertical line in this case that is true
or false the result ends up being true
and of course we can apply not operator here as you saw earlier which changes
the true to false
now this expression doesn't really look easy to understand it's just purely for
demonstration of how we can combine different operators and make up more
complicated expressions okay that's it for this lecture I hope you enjoyed it
and thank you for watching
okay so we got to comment a comment is text that we put in our code to improve
its readability and maintainability in C# we have two ways to write
comments if your comment is only a single line you can prefix the comment
with double slash but if your comment is longer and it's multiple lines you need
to start it with slash star and then finish it with star slash this type of
comment is more like the comments we used to write in C and C++ code these
days it's more conventional to write either single line or multi-line
comments prefixing with double slash so in this example we can rewrite this
multi-line comment with double slash style like this now as a rule of thumb
keep your comments to minimum use comments only win required and that's
when explaining wise house constraints and things like that do not explain what
the code is doing your code should be so clean and straightforward that it
doesn't need comment if a comment explains just what the code is doing is
redundant and the problem with redundant comments is we change the code but not
everyone is very consistent in changing the comments so after a while these
comments become outdated and because they don't get compiled like the code
there is no way to validate them and after a while they become useless so
again keep them to minimum and explain wise house and constraints that you had
at the time you wrote the code so the next person who is reading your code
knows the reason why you wrote the code that way
in this section you learn that C# is a statically typed language which
means once you ticular a variable you need to specify its type and that type
cannot change during the lifetime of that variable you also learn about the
primitive types in C# such as integer character boolean and so on now
in the next section I'm going to introduce you to non primitive types in
C# such as classes or structures arrays strings and in ohms so I'll see
you the next section