Posts
what is dot net framework
NET Framework may be a framework which is employed to run
.NET software that you simply install in your Windows, and these sorts of
software cannot run without .NET Framework in your system.
After installing .NET Framework, a software environment is
made and it provides your downloaded software with an adequate runtime for
working. .NET Framework are often easily installed in Windows NT, 1998, 2000,
Windows 7, 8 and Windows Server of 2008 and 2012 too.
.NET Framework All Versions Offline Installers Direct Download Links
.NET
Framework run-time may be a Microsoft product which is employed to run the
applications made with Visual Studio using this framework. For installation,
you'll bundle the .NET framework redistributable for the version of .NET that
your application needs together with your installer.Why Do You Need It?
we were happy with it by the time Windows came out we were
ready for a graphical user interface in the early 90s when Windows finally
became usable Windows sat on top of dos and windows apps.
required the Windows
runtime environment in order to be able to run you may not remember this but
apps like Microsoft Word required Windows but lots of people didn't have
Windows installed.
so you could at the
time be running dos as your normal operating system and just install Windows
long enough to run word and then close it up when you're done in Windows went
away again because people didn't really like Windows back then anyway so
Windows apps provide a consistent API for communicating with drivers and
devices and so on in my past life I spent years writing device drivers for
printers and screams for a DOS based application and assembly language well when Windows came out my job as they say
became redundant because Windows provided those services by hosting drivers
internally so I didn't have to write them anymore so that's 1991 by 2001 we
have a very similar situation the .net
runtime sits on top of Windows just
like Windows sat right on top of DOS
dotnet apps require the dotnet
runtime environment enabled to be able to run dotnet apps provide a consistent API for working with Windows data
structures data types and more so you can think of the.net runtime as just a
windows on top of Windows.
that provides more
services for applications and developers you can think of the.net runtime as an environment that
handles data types memory management api's
and much much more as you'll see so why are you here why does anyone care
about dotnet well before dotnet software development require
mastery of multiple technologies and authoring tools you generally had to
manually stitch together various programming tools in order to build your
applications for example if you want to build a website .
You had to learn VB scripting or Jscript and HTML and
some of the pretty ugly tools available for building websites if you wanted to
build database apps you'd have to
learn SQL and SQL server most likely.
Or some other server
application if you wanted to build
business applications well most likely Visual
Basic would have been your language of choice if you want to build office applications ,VBA and managed to work in a based environment with office objects using
that scripting language if you
wanted to build streamlined graphics
applications most likely you use C++
to do your work dotnet provides
remedies for these issues it provides an object-oriented
view of windows.
A brief history of donet?
the dotnet framework
encapsulate slots of functionality into groups of classes the application
security is built-in you don't have to worry about providing your own authentication and authorization tools it's all built into the dotnet framework deploying applications on the dotnet framework is easier as well because all of the dotnet application exists in containers
called assemblies and these
containers will you can deploy them without having to add entries to the
registry or worry about installing other bits and pieces the dotnet framework and your assembly is all you really need to run
an application for the most part you don't need to worry about versioning
issues how many times have you built applications and then attempted to deploy
a newer version and dealt with all of the issues involved in that the.net runtime largely handles those
issues without much effort on your part assemblies can be digitally signed.
using authentic code
as one of the options you can see or users can see who authored the application the helps users make intelligent decisions
about which applications are safe to install and run and unless.
You're using common and you can although we won't cover that in
this course there's no need for registration you don't need to write things to
the Windows registry in order to run
your applications.
now you can if you
want but you don't have to work with common and the registry
in addition all dotnet languages are
interoperable you can write some pieces of your application in VB others in c-sharp and others in some other language.
If you want and they
can all communicate with each other and this leads us to the concept of the.net framework architecture if we stop and take a look at this picture
which I'm guessing you've probably.
the documentation about
dotnet what you see at the bottom is windows
and common services which indicates that
all this still sits on top of Windows and
the features provided by Windows now
I will mention that there are versions of the.net framework that are currently running on other platforms there
are initiatives outside Microsoft to
cross port the dotnet framework to Linux to the Mac.
we'll be focusing on Microsoft
technologies and using Windows
and starting there on top of Windows app the common language runtime is a set of services that provide all the
features we'll use when running dotnet
applications on top of that is the base class library is a set of classes that provide all the
functionality that you can take advantage of in your dotnet applications.
now within the base class library we have various groups of
classes this diagram that shows a couple a donet
and XML for example is a common way to work with data using the base
class library the.net runtime and so on now we also have
various ways to build applications
asp.net allows us to build web applications
windows forms is the common name for the platform built into the dotnet framework for building windows or client-side applications in addition to all the user interface and
classes.
there is a common
language specification which identifies what languages must provide in order to
work in the dotnet world this
specification is public so anyone who cared to could write a language that fit
in with the rest of these tools many vendors have done that Microsoft ships languages like VB ,C++, C sharp and jscript
with Visual Studio.
but you can find lots
of other languages like Python COBOL
,Fortran and others that work in the
dotnet environment and use this same
set of services and classes as the languages we'll look at here now all of that
is free you don't need to pay get all of
those tools if you actually want to be productive however.
you'll want to also
find a copy of Visual Studio it was
originally called visual studio.net
some people still call it that because it is the dotnet version of Visual
Studio it's the common language runtime that provides a runtime environment for all your dotnet applications we call it the CLR .
purpose is to load and run
applications that have been compiled to intermediate language IL some people call it MS for Microsoft intermediate language but
it's just an intermediate language
that the compilers create every dotnet
compiler creates IL as its output we'll look later at how that il becomes
executable code the CLR manages dotnet based services like memory management ,garbage
collection .
you know removing things from memory when they're done
exception handling that is handling errors and applications and that's
important to notice that this is here at the CLR level which means that applications
have a standard and common way to
bubble exceptions from one application
or one seizure to another so it's not up to each individual procedure to handle
exceptions it's handled by the CLR in addition obviously the common language runtime is in charge of
loading and running applications.
let's stop and look
at how the CLR runs code the CLR allows you to run both managed and
unmanaged code and one of those words even mean unmanaged code is code that
runs outside the common language runtime
that is code that was written before we had the dotnet runtime like vb6
or native C++ code that were
compiled without dotnet.
although it's not the
common language runtime that loads these things applications can cause these to be
loaded and they'll still work with the CLR
running at the same time managed code runs within the CLR and benefits from all the CLRS
features memory management garbage
collection and so on now as I mentioned the CLR and it's compilers create
MSI L on output they don't create native code they create il at execution
time the just-in-time compiler converts
that il code to native executable and this little picture diagrams that if we
start with any dotnet language the language compiler at compile time.
creates ms IL code as you see in the middle of the
diagram then at runtime there's a just-in-time compiler often called a JIT compiler that creates executable native code from that MS IL you might think this is a
drawback but it actually adds some extra benefits the JIT compiler takes the native processor into account it creates code
optimized for the local environment if it can that is the JIT compiler can make decisions about how to optimize your code at
runtime therefore if you were to install
your application to a computer
say with a pen three processor I know
there are some out there still and then install it on a computer with a Pentium 4 processor or something even
better who knows the just-in-time
compiler could make different runtime
decisions about how to compile that code into native executable so it would
behave best for each individual.
computer now it only
needs to compile the application
once the compiled bits are cached
locally the performance overhead is very slight if any so you really needn't
worry about for most applications any overhead involved in that first JIT compilation and it's a far more complicated procedure that I'm showing
here it doesn't JIT the entire application it only loads the pieces it
compiles the assemblies.
we'll talk more about what an assembly is
soon it only compiles the parts it needs and puts off compiling others until it
actually uses them remember the dotnet
runtime and included with it the common language runtime must be installed
on client computers in order to run dotnet
code of course .
there's a question of how it's going to get there on some
computers it will already be there if you're running Windows Server 2003 for example a version of the.net runtime is already there Microsoft Update for many users
downloads the.net framework for the
user it's a not a small download and it's not something you should take lightly
you can't install it from a floppy for example but what's a floppy anyway at
this point let's take a moment and look at the BCL the base class library this consists of classes that provide
base functionality for the.net framework and many classes also then make your
life as a developer easier I sort of
found that at any point if there's something I need that I think other people
may have needed before me I don't write it myself I look in the dotnet framework.
documentation and I'm likely to find it there this is a library of classes that are used by all
dotnet applications and you should as you become a more experienced net developer become more and more
aware of what's actually in the dotnet
framework based class library
that will make your life easier the base class
library contains a large number of classes and you might be wondering what
is a class .
now think of a class
as just a block of functionality including properties that is something that
describes this class methods that is something that the class can do when
action it can take and events that is a way of providing notifications about
the class grouped into namespaces and a namespace is just a grouping of classes
in which every class has a unique name the base class libraries namespaces
group classes into common blocks of functionality so that all the classes
dealing with file input and output are all in one namespace all the classes
dealing with data management are all in a single namespace it's just a way of
grouping things so you can find them the get you started here are some common
or things.
you'll use often base
class library namespaces for example
there's the system namespace this includes all the essential support you'll
need for programming including base
types like strings integers date/time
boolean .
so on there's math functions garbage collection ,memory
management and more all within the system namespace every application will
use classes from the system namespace
there's no way around it.
there's the system dot data namespace notice that dot they use the dot as a hierarchical organization tool
everything for the most part comes under the system namespace so you will name it system dot.
something now there's
other root namespaces there is a Microsoft root namespace for things
that applications that aren't using Microsoft tools might not use but for
things that are part of the base class
library.
that every dotnet
that application will use the root namespace is generally system data is a namespace that provides class for working
with data including sql server ,ODBC
and so on system Diagnostics provides
the classes you need to diagnose including event logging performance counters
tracing and process management you'll find lots of good tools in the system Diagnostics
namespace system globalization well that provides fundamental support for globalization that is translating
applications.
to work in multiple
locales and it's used throughout the entire dotnet framework so many different methods in the.net framework use features from system
globalization to be able to provide
well globalized versions of your applications there's the system dot IO namespace which provides.
fundamental support
for working with well the technology is called a stream and a stream is a class that provides functionality for
moving data from one place to another because that's what input/output is about
right io, system.net .
it's about moving data from one place to another now the end
point of that might be a disk file so there's plenty of support in here for
working with disks files folders and so on and throughout this course this
namespace gets used a lot because it's a great way to show off examples of
other things we'll look a lot if system dot io classes in this course the
system dot text namespace includes functionality for working with text and
coding it also includes the string builder class .
demonstrations there's system dot text regular expressions
and here you can see that the dotnet
framework isn't above creating multiple nested namespaces their system text
out regular expressions or regular
expressions provide a subset or a certain corner of text operations that
allow you to provide support for robust parsing and matching of string data system. web provides design
time and runtime support for creating and displaying web applications if you're
using web applications you'll be living in the system.web namespace system .windows .forms is the namespace that
provides all of the features .
you'll use when building windows applications all the
controls all the forms all the features of Windows
applications live in this namespace system . XML provides support for
reading and writing XML content and here we've covered about ten of the
hundreds and hundreds of namespaces in the.net
framework .
we will focus on several different namespaces and the classes within them Microsoft provides several dotnet
languages including Visual Basic, C
sharp ,C++ ,jscript and other
vendors provide other languages like Python,
Fortran ,COBOL and not only we know what Python is but I'm sure you do and
you'll find that you can use it within the dotnet
runtime environment.
how do these languages interoperate well dotnet provides the common language specification which
describes.
how a dotnet language
should work in addition the common type system don't you love those
three-letter acronyms CTS describes how data types should work together so that
you can write code that uses a string and somebody else can write code in the
different language that uses a string and all of us can play along together in
the end all dotnet languages compile
il.
and we'll be looking at some il.
we'll need to think about what an assembly is what you get when you compile manage code you compile
it you get an assembly that's what
comes out the other side theoretically an assembly can contain multiple modules
although Visual Studio only supports
creating a single module assembly .
find version name culture and security requirements there's
a list of other files in the assembly
and also a cryptographic hash for each file so the dotnet runtime can tell if the file has been modified there's a
list of public types types that are exposed by this assembly.
and a list of external required references other things
this assembly needs in order to run
will be looking at il that's the il dis
assembler which comes with the dotnet
framework to examine the contents in just a moment we'll take a look at a dotnet assembly and see what's actually
in there so what are your options you can create a large range of applications
with net Visual Studio includes templates for these items among a few others Windows applications console applications
and we'll be building console applications throughout we don't know what your
goal is we're not sure if you're building Windows
apps or web apps .
.NET Framework All versions direct download links
Download .NET Framework 1.0
Download .NET Framework 1.1
Download .NET Framework 2.0
Download .NET Framework 3.5
Download .NET Framework 4.0
Download .NET Framework 4.5
Download .NET Framework 4.5.1
Download .NET Framework 4.5.2
Download .NET Framework 4.6
Download .NET Framework 4.6.1
Download .NET Framework 4.6.2
Download .NET Framework 4.7
Download .NET Framework 4.7.1
Download .NET Framework 4.7.2
Download .NET Framework 4.8
Post A Comment:
0 comments: