Highlypersonalized Web experience: Microsoft .NET Framework v 3.5

motionslatelickSoftware and s/w Development

Nov 2, 2013 (3 years and 5 months ago)

75 views

Highly­personalized Web experience: Microsoft .NET 
Framework v 3.5 
White Paper 
– Microsoft .NET Framework v3.5
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
Contents
 
Overview
..................................................................................................................................................3 
1. Principal design features
...................................................................................................................4 
2. Architecture
.........................................................................................................................................6 
2.1 Common Language Infrastructure (CLI)
......................................................................................6 
2.2 Assemblies
.....................................................................................................................................6 
2.3 Metadata
........................................................................................................................................7 
2.4 Security
..........................................................................................................................................7 
2.5 Class library
...................................................................................................................................7 
2.6 Memory management
...................................................................................................................8 
3. Versions
...............................................................................................................................................9 
3.1 The .NET Framework 3.5 and its Predecessors
.........................................................................9 
4. Conclusion
.........................................................................................................................................
11
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved. 
While every attempt has been made to ensure that the information in this document is accurate and complete, some typographical 
errors or technical inaccuracies may exist. Scalable Systems does not accept responsibility for any kind of loss resulting from the use of 
information contained in this document. 
This page shows the publication date. The information contained in this document is subject to change without notice. 
This text contains proprietary information, which is protected by copyright. All rights are reserved. No part of this document may be 
photocopied, reproduced, stored in a retrieval system, transmitted in any form or by any means, or translated into another language 
wi
thout the prior written consent of Scalable Systems Inc.
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
Overview
:
 
The .NET Framework is a key Microsoft offering that is presented with several Microsoft Windows 
operating systems 
and is projected to be used by most new applications created for the Windows 
platform. It has a large library of coded solutions that avoids 
common programming problems and a 
virtual machine that deal with the execution of programs written specifically for the framework. 
The  pre­coded  solutions  called  as  framework's  Base  Class  Library(BCL) 
cater 

numerous 
programming  needs  in  a  number  of  areas,  including  user  interface,  data  access,  database 
connectivity,  cryptography,  web  application  development,  numeric 
algorithms,  and  network 
communications.  The  BCL  is  used  by  programmers,  who  unite  it  with  their  own  code  to  produce 
applications. 
Code
s  written for  the .NET  Framework  execute  in  a  Common  Language  Runtime  (CLR) 
that  is a 
software  environment  that 
deals  with 
the  program's  runtime  requirements.  The  CLR  presents 
the 
look of an application virtual machine so that programmers need not consider the capabilities of the 
particular CPU that will 
run and execute 
the program. The CLR also provides 
some other important 
services  such  as  security,  memory  management,  and exception  handling.  The  BCL  and  the  CLR 
together compose the .NET Framework
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
1. Principal design features 
Interoperability
 
Interoperability  is  a  feature  which  refers 
to  the  ability  of  diverse  systems  and 
organizations 
exchange  information  via  a  common  set  of  exchange  formats.  In 
recent  world’s  heterogeneous 
computing 
arena,  interoperability  has  become  a  critical  business  and  IT  requirement. 
The .NET 
Framework 
offers  reasons 
to  access  functionality  that  is 
implemented  in  programs  that  execute 
outside the .NET environment, 
to facilitate interaction between new and older applications. Access 
to COM components  is provided in  the System.Runtime.  Interop Services and System.  Enterprise 
Services namespaces of the 
framework; access to other functionality is provided using the P/Invoke 
feature.
 
Common Runtime Engine
 
The Common Language Runtime (CLR) is the virtual machine constituent of  the .NET framework. 
The  engine  that  compiles  the  source  code  in  to  an  intermediate  language. 
All .NET  programs 
execute  under  the  supervision  of  the  CLR, 
assured 
certain 
traits 
and  behaviors  in  the  areas  of 
memory management, security, and exception handling.
 
Language Independence
 
The .NET Framework brings in 
a Common Type System, 
(CTS).  The CTS specifications describe 
all  possible  data  types and  programming  constructs  supported by  the  CLR  and  how  they  may  or 
may not interact with each other. 
Due to 
this feature, the .NET Framework supports the exchange 
of instances of types between 
programs written in any of the .NET languages.
 
Base Class Library
 
The  Base  Class  Library  (BCL), 
an  element 
of  the  Framework  Class  Library  (FCL),  is  a  library  of 
functionality  available  to  all  languages  using  the .NET  Framework.  The  BCL 
offers 
classes  which 
encapsulate  a number of  common functions,  including file  reading and  writing,  graphic  rendering, 
database interaction and XML document manipulation.
 
Simplified Deployment
 
The .NET  framework  comprises 
design  features  and  tools  that  help  manage  the  installation  of 
computer software to ensure that it does not interfere with previously installed software, and that it 
conforms to security requirements.
 
Security
 
The design is meant to address some of  the flaws, 
like 
buffer overflows,  that have been exploited 
by malicious software. Additionally, .NET provides a common security model for all applications.
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
Portability
 
Design  of  the .NET  Framework  permits 
it  to  hypothetically  be  platform  agnostic,  and  thus  cross­ 
platform compatible. That is, a program written to use the framework should run without change on 
any  type  of  system  for  which  the  framework  is  implemented.  Microsoft's  commercial 
implementations o
f the framework cover Windows, Windows CE, and the Xbox 360.[3] In addition, 
Microsoft submits the provisions 
for the Common Language Infrastructure (which includes the core 
class  libraries,  Common  Type  System,  and  the  Common  Intermediate  Language),[4][5][
6]  the  C# 
language,[7]  and the  C++/CLI  language[8]  to both  ECMA  and  the  ISO,  making  them  available  as 
open standards. This makes it easier 
for third parties to create companionable implementations of 
the framework and its languages on other platforms.
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
2. Architecture 
2.1 Common Language Infrastructure (CLI)
 
The core aspects  of the .NET Framework lie within  the Common Language Infrastructure, or CLI. 
The purpose of the CLI is to provide a language­
neutral platform for application development and 
execution,  including  functions  for  exception  handling,  garbage  collection,  security,  and 
interoperability. Microsoft's implementation of the CLI is called the Common Language Runtime or 
CLR.
 
2.2 Assemblies
 
The  intermediate  CIL  code  is  housed  in .NET  assemblies.  As  mandated  by  specification, 
assemblies are  stored  in  the  Portable  Executable  (PE) 
format, common on the Windows  platform 
for all DLL and EXE files. The assembly consists of one or more files, one of which must contain the 
manifest, which has the metadata for the assembly. The complete name of an assembly (not to be 
confused  with  the  filename  on  disk)  contains  its  simple  text  name,  version  number,  culture,  and 
public key token. The public key token is a unique hash generated when the assembly is compiled, 
thus two assemblies with the same public key token are guaranteed to be identical from the point of 
view  of  the  framework.  A  private  key  can  also  be  specified  known  only  to  the  creator  of  the 
assembly and can be used for strong naming and to guarantee that the assembly is from the same 
author when a new version of the assembly is compiled 
(required to add an assembly to the Global 
Assembly Cache).
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
2.3 Metadata
 
All CLI is self
­describing through .NET metadata. The CLR checks the metadata to ensure that the 
correct method is called. Metadata is usually generated by language compilers but developers can 
create  their  own  metadata  through  custom  attributes.  Metadata  contains  information  about  the 
assembly,  and  is  also  used  to  implement  the  reflective  programming  capabilities  of .NET 
Framework.
 
2.4 Security
 
.NET  has  its 
predefined 
security  mecha
nism  with  two  general  features:  Code  Access  Security 
(CAS), and 
V
alidation 

verification. Code Access Security is stands on evidence that is linked with 
a specific assembly. 
Usually the evidence is the source of the assembly (whether it is installed on 
the  local  machine  or  has  been  downloaded  from  the  intranet  or  Internet).  Code  Access  Security 
uses  evidence  to  determine  the  permissions  granted  to  the  code.  Other  code  can  demand  that 
calling code is granted a specified permission. The demand causes the CLR to perform a call stack 
walk: every assembly of each method in the call stack is checked for the required permission; if any 
assembly is not granted the permission a security exception is thrown. 
When  an  assembly  is  loaded  the  CLR  performs  various  tests. 
Two  such  tests  are  validation  and 
verification. During validation the CLR checks that  the assembly contains valid metadata and CIL, 
and whether the internal tables are correct. Verification is not so exact. The verification mechanism 
checks to see if the c
ode does anything that  is 'unsafe'. The algorithm used is quite conservative; 
hence  occasionally  code  that  is 'safe'  does  not  pass.  Unsafe  code  will  only  be  executed  if  the 
assembly has the 'skip verification' permission, which generally means code that is 
installed on the 
local machine. 
.NET  Framework  uses  appdomains  as  a  mechanism  for  isolating  code  running  in  a  process. 
Appdomains  can  be  created  and  code  loaded  into  or  unloaded  from  them  independent  of  other 
appdomains.  This helps increase the fault tolerance of the application, as faults or crashes in one 
appdomain do not affect rest of the application. Appdomains can also be configured independently 
with different security privileges.  This can help increase the security of  the application by isolating 
potentially unsafe code. The developer, however, has to split the application into subdomains; it is 
not done by the CLR.
 
2.5 Class library
 
The .NET Framework includes a set of standard class libraries. The class library is organized in a 
hierarchy  of  namespaces.  Most  of  the  built  in  APIs  are  part  of  either  System.*  or  Microsoft.* 
namespaces. It encapsulates a large number of common functions, such as file reading and writing, 
graphic rendering, database interaction, and XML document manipulation, among others. The .NET 
class libraries are available to all .NET languages. The .NET Framework class library is divided into 
two parts: the Base Class Library and the Framework Class Library. 
The Base Class Library (BCL) includes a small subset of the entire class library and is the core set 
of  classes  that  serve  as  the  basic  API  of  the  Common  Language  Runtime.[9]  The  classes  in
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
mscorlib.dll and some of the classes in System.dll and System.core.dll are considered to be a part 
of  the  BCL.  The  BCL  classes  are  available 
in  both .NET  Framework  as  well  as  its  alternative 
implementations including .NET Compact Framework, Microsoft Silverlight and Mono. 
The Framework Class Library (FCL) is a superset of the BCL classes and refers to the entire class 
library  that  ships  with .NET  Framework.  It  includes  an  expanded  set  of  libraries,  including 
WinForms,  ADO.NET,  ASP.NET,  Language  Integrated  Query, Windows Presentation  Foundation, 
Windows  Communication  Foundation  among  others.  The  FCL  is  much  larger  in  scope  than 
standard  libraries  for  languages  like  C++,  and  comparable  in  scope  to  the  standard  libraries  of 
Java.
 
2.6 Memory management
 
The .NET  Framework  CLR  frees  the  developer  from  the  burden  of  managing  memory  (allocating 
and  freeing  up  when  done);  instead  it  does  the  memory  manag
ement  itself.  To  this  end,  the 
memory  allocated  to  instantiations  of .NET  types  (objects)  is  done  contiguously[10]  from  the 
managed heap, a pool of memory managed by the CLR. As long as there exists a reference to an 
object, which might be either a direct 
reference to an object or via a graph of objects, the object is 
considered  to  be  in  use  by  the  CLR.  When  there  is  no  reference  to  an  object,  and  it  cannot  be 
reached or used, it becomes garbage. However, it still holds on to the memory allocated to it. .NET 
Framework  includes  a  garbage  collector  which  runs  periodically,  on  a  separate  thread  from  the 
application's thread, that enumerates all the unusable objects and reclaims the memory allocated to 
them. 
The .NET  Garbage  Collector  (GC)  is  a  non­deterministic,  compacting,  mark­and­sweep  garbage 
collector.  The GC runs only when a certain amount of  memory has been used or there is enough 
pressure  for  memory  on  the  system.  Since  it  is  not  guaranteed  when  the  conditions  to  reclaim 
memory are reached, the GC runs are non­deterministic. Each .NET application has a set of roots, 
which are pointers to objects on the managed heap (managed objects). These include references to 
static  objects  and  objects  defined as  local  variables  or  method parameters  currently  in  scope, 
as 
well as objects referred to by CPU registers.[10] When the GC runs, it pauses the application, and 
for each object  referred to in the root, it recursively enumerates all the objects  reachable from the 
root  objects  and  marks  them  as  reachable.  It  uses .NET  metadata  and  reflection  to  discover  the 
objects  encapsulated  by  an  object,  and  then  recursively  walk  them.  It  then  enumerates  all  the 
objects  on  the  heap  (which  were  initially  allocated  contiguously)  using  reflection.  All  objects  not 
marked  as  reachable 
are  garbage.[10]  This  is  the  mark  phase.[11]  Since  the  memory  held  by 
garbage is not of any consequence, it is considered free space. However, this leaves chunks of free 
space between objects  which  were  initially  contiguous.  The  objects are  then compacted 
together, 
by using memcpy[11] to copy them over to the free space to make them contiguous again.[10] Any 
reference to an object invalidated by moving the object is updated to reflect the new location by the 
GC.[11] The application is resumed after the garbage collection is over. 
The GC used by .NET Framework is actually generational.[12] Objects are assigned a generation; 
newly  created  objects  belong  to  Generation  0.  The  objects  that  survive  a  garbage  collection  are
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 

Copyright ©2009 Scalable Systems. All rights reserved.
 
tagged  as  Generation  1,  and  the  Generati
on  1  objects  that  survive  another  collection  are 
Generation 2 objects. The .NET Framework uses up to Generation 2 objects.[12] Higher generation 
objects are garbage collected less frequently than lower generation objects. This helps increase the 
efficiency 
of  garbage  collection,  as  older  objects  tend  to  have  a  larger  lifetime  than  newer 
objects.[12] Thus, by removing older (and thus more likely to survive a collection) objects from the 
scope of a collection run, fewer objects need to be checked and compacted
 
3. Versions
 
I
n  2002 
first  released  and 
version  2.0  of  the  Framework 
comes  out 
three  years  later.  The .NET 
Framework 3.0, released in 2006, was a 
perfect 
update 
that added a number of new technologies, 
while  the  latest  version,  the .NET  Framework  3.5,  includes 
numerous 
useful  add­ons.  The  latest 
release, Visual Studio 2008, offers a range of developments 
for creating .NET applications.  Every 
step  in  this  path  has 
been  aimed  at  providing  a  better  and  more  productive  environment  for  the 
people who create Windows software.
 
3.1 The .NET Framework 3.5 and its Predecessors
 
The .NET  Framework  3.5  is  the  latest  step  in  the  evolution  of  Microsoft’s  flagship  development 
platform, with each step building on what came before. This most recent release is a superset of the 
.NET Framework 3.0, and it brings no breaking changes. Similarly, the .NET Framework 3.0 was a 
superset of the 2.0 release, and it also contained no breaking changes. To help make the stages in 
this evolution clear, the figure below shows what’s been added in the 30 and 3.5 releases.
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 
10 
Copyright ©2009 Scalable Systems. All rights reserved.
 
Everything in the .NET Framework depends, as it always has, on the Common Language Runtime 
(CLR). A large group of classes, known as the .NET Framework class library, is built on top of the 
CLR. This library has expanded with each release, as the figure shows. The .NET Framework 2.0 
provided the fundamentals of a modern development 
environment, including the base class library, 
ASP.NET, ADO.NET, and much more. The .NET Framework 3.0 didn’t change any of this, but it did 
add four important new technologies: WCF, W
W
F, WPF, and Windows CardSpace. 
The alterations 
in  the .NET  Framework  3.5 affect  several parts  of  the 3.0  release.  ASP.NET  gets 
AJAX  support,  while  LINQ  is  offered  for  use  with  ADO.NET  and  in  other  ways. 
Several 
add­ons 
were  made  to  the  base  class  library, 
such  as  addition  of  a  type  supporting  sets
—unordered 
collections of exclusive elements
—and improved encryption support. WCF, WF, and WPF each get 
enhancements  as  well. 
The  set  of  operating  systems  on  which  the  Framework  runs  was  also 
updated:  The .NET  Framework  3.5  runs  only  on  Windows  Server  2008,  Windows  Server  2003, 
Windows Vista, and Windows XP. 
Due to each release adjoins to its ancestor; the need to retest applications came 
for earlier releases 
are  minimized.  Also, 
as 
all  three  versions  can  run  simultaneously,  it’s  still  possible  to  run 
applications  on  older  versions  of  the  Framework  if  required
.  Visual  Studio  2008  even  allows 
creating projects that  target a particular version of the Framework.  An application built  in  this way 
will use only the binaries for that  version, and the developer will see only those aspects of Visual 
Studio and the Framework itself that work in this older world. A developer who chooses to build a 
new application targeting the .NET Framework 2.0, for example, can make his world 
look just as if 
only this older version of the Framework were available.
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 
11 
Copyright ©2009 Scalable Systems. All rights reserved.
 
4. Conclusion
 
The .NET  Framework  3.5  is  the  most  up­to­date  manifestation  of  the  mainstream  Windows 
programming environment. Built on and extends 
its predecessors, its goal is to 
support the creation 
of modern applications. By building its various technologies on a common foundation, Microsoft  is 
striving to make the whole greater than the sum of the parts, letting developers create applications 
that use the various parts of the .NET Framework 3.5 in a coherent way
.
Highly
­
personalized Web 
experience: Microsoft .NET Framework v 3.5
 
12 
Copyright ©2009 Scalable Systems. All rights reserved.
 
Copyright © 2008 Scalable Systems. All Rights Reserved. 
While every attempt has been made to ensure that the information in this document is accurate and 
complete, some typographical errors or technical 
inaccuracies may exist. Scalable Systems does not accept responsibility for any kind of loss resulting from the use of inform
ation contained in this 
document. The information contained in this 
document is subject to change without notice. 
Scalable Systems logos, and trademarks or registered trademarks of Scalable Systems or its subsidiaries in the United States and other countri
es. 
Other names and brands may be claimed as the property of others. Information regarding third party products is provided solel
y
for educational purposes. 
Scalable Systems is not responsible for the performance or support of third party products and does not 
make any representations or warranties 
whatsoever regarding quality, reliability, functionality, or compatibility of these de
vices or products
 
About Scalable Systems:. 
Scalable Systems is a premier global IT consulting, development and outsourcing 
company providing both offshore and onshore software solutions and integration 
services to business enterprises around the
globe. Scalable Systems has proven 
expertise in encompassing low cost, but high quality and reliable software solutions and 
services in areas like Data Warehousing, Business Intelligence, Enterprise Resource 
Planning, Web and Custom Application Development. 
Scalable Systems Inc
 
525 Milltown Road, Suite 303 
North Brunswick, NJ 08902, USA 
Tel : 
(732) 
993 
4320 
Fax: (732) 909 2732 
Email: 
info@scalable
­systems.com