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
type
s 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 i
s 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 lan
guages 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 langua
ges 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 system
s 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 wr
ite 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
clas
s 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 kin
d 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 comp
lexities 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 appli
cation 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 nee
d 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 thi
s 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 mo
st 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 cod
e 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 l
ike 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 progr
am 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 entr
y 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 w
hich 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 t
his 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 i
ntroduce 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 o
f 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 differe
nt 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 ju
mp 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 Hungari
an 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 identifie
r 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 dec
imal
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 w
ould
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 conc
ept 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
overflo
w 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 thi
s 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 i
f 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 typ
e 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 i
s 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 var
ious 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
th
at 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 f
ields 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
con
trol 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
ba
sically 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 ty
pe 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
a
nd 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
b
ut 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 byt
e 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 an
d 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 th
at 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
h
ave 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 manu
ally 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 i
n
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 i
s 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 strin
g 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 h
ere 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 eith
er 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 state
ments 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 def
ault 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
propagate
d 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 boolea
n 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 pur
ely 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 thei
r
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 t
ake 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 a
nd 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
indicat
ed 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 sho
w 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 equ
al
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 r
id 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 earl
ier 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 pref
ix 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 u
se
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 th
e 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
Comments