Introduction to Cloud Computing Windows® Azure™

•  Wikipedia defines cloud computing as: 

◦       “Internet-based computing, whereby shared resources, software and information are provided to computers and other devices on-demand, like the electricity grid.”

◦       The idea behind cloud computing is to access software applications and/or data from resources available through the Internet with a simple browser.

◦       In cloud computing, you pay for the resources (applications and data) you use, as you go.

•  Key reasons for shifting to cloud computing include cost savings, improved scalability and reliability, and availability of applications/data anywhere.

Why is it important

•  Companies incur a capital expenditure when spending money on a fixed asset like a data center or hardware.

Types of Cloud Computing Services

Windows Azure

•   Windows Azure is a cloud platform that enables you to quickly build, deploy and manage applications across a global network of Microsoft-managed datacenters. 

•   Can integrate your public cloud applications with your existing IT environment.

•   Windows Azure delivers a 99.95% monthly SLA and enables you to build and run highly available applications without focusing on the infrastructure.

•   It provides automatic OS and service patching, built in network load balancing and resiliency to hardware failure. 

•   You can use any language, framework, or tool to build applications. Features and services are exposed using open REST protocols. The Windows Azure client libraries are available for multiple programming languages, and are released under an open source license and hosted on GitHub.

Windows Azure Architecture

•  The hyper visor (Microsoft optimized Hyper-V ) runs on each server.  It manages and controls the virtual servers running on the physical server.

•   Each virtual partition in the Microsoft cloud runs a modified version of Windows Server 2008 R2 Enterprise Edition.

Windows Azure cloud computing platform (PaaS).

 

 Fabric Controller functions as the kernel of the Azure platform. It provisions, stores, delivers, monitors and commands the virtual machines (VMs) and physical servers that make up Azure.

AppFabric (formerly .NET Services) provides many enterprise-level services to include access control, caching and distributed messaging via a service bus.

•  Microsoft provides the hardware and software to host your applications, more formerly known as services, and data.

◦       Web site

◦       Computational service

•       You can access the data via an HTTP API from inside or outside the data centers.

•       You pay for the computational processing and storage in Windows Azure on a consumption model – that is in a pay as you go and for what you use manner.

Windows Azure Storage

Tables, blobs Storage, Queues & SQL Azure

•   You access Windows Azure Storage (any of the three types) through a REST API over HTTP.
•  Tables, blobs and queues storage types, allowing data to be stored in non-relational database.
•   structured tables similar to what you   would find in a relational database, but   without indexes and relationships

•   Binary Large Object (Blob) storage houses large binary data such as images, videos, music, documents

•   SQL Azure to support relational database needs

•   SQL Azure uses a special version of Microsoft SQL Server as its backend.

• There are differences between SQL Azure and SQL Server 2008 there are number of limitations and unsupported features found in SQL Azure.

•   You access SQL Azure data with all the standard tools (Management Studio) and APIs that work with SQL server. (ADO.NET and ODBC APIs)

•   SQL Azure supports typical ACID transactions for work within the same database.

•   SQL Azure is more expensive than Windows Azure Storage, and in particular table storage.

SQL Azure Architecture

•   While SQL Azure is based on SQL Server, the architecture is such that you are not connecting directly to SQL Azure as you might connect to SQL Server.

Senior .NET Developer & Architect Skills List you must improve

Programming

• General Programming Skills (Data Types, Iteration, Functions)
• Algorithm Proficiency
• Unary/Binary Operation Proficiency
• Declarative Programming Fundamentals
• Regular Expression Familiarity
• Framework Design Guideline Proficiency
• Collection/Array Differences

Language Specific Skills

• C# (or VB) Mastery
• Enumerators
• Delegates and Events
• Nullable Types
• Generics
• Preprocessor Directives
• P/Invoke Fundamentals
• COM Interop Fundamentals
• XML Documentation

CLR/Framework

• CLI Fundamentals (Memory Management, Assembly Loading)
• Framework Type Mapping (int -> Int32, long -> Int64)
• IL Fundamentals
• Framework Navigation Fundamentals
• Reflection / Dynamic Invocation
• Understanding of the 'Object' Type
• Core Assemblies
• Global Assembly Cache (GAC)
• Boxing/Unboxing Fundamentals

ASP.NET

• ASP.NET Concepts (CodeBehind, Compilation Model, Intrinsic Objects, ViewState, etc)
• ASP.NET Control Proficiency
• ASP.NET Page Life Cycle
• ASP.NET HttpHandler, HttpHandlerFactory, and HttpModule Proficiency
• Object-Oriented Nature of ASP.NET

Client-Side Development / General Web Development

• JavaScript Proficiency (Closures, Anonymous Calls, etc)
• CSS Proficiency (Specificity, Selectors, Rules, etc)
• DOM Familiarity
• XHTML Mastery (and it's relation to HTML)
• Web Standards Familiarity
• MOS (Mozilla, Opera, Safari) and IE Development Differences
• Firefox Utilities (Firebug, Web Developer Toolbar)
• Core Ajax & JQuery Fundamentals
• Classic Web Development Concepts (State Management, Stateless Development)
• WPF
• Silverlight

.NET Data

• ADO.NET Fundamentals (DataTable, DataSet, DataColumn, etc)
• LINQ
• Entity Framework
• Data Binding Fundamentals
• XML Serialization

.NET Concepts

• Assemblies
• Exception Handling
• Streaming
• Attributes
• Versioning
• Strong Naming
• Disposable Resources (and IDisposable)

Object-Oriented Principles

• OOP Principles (Inheritance, Polymorphism, Encapsulation) Proficiency
• OOD GRASP Patterns Mastery
• OOD GoF Pattern Fundamentals
• UML Fundamentals

Enterprise Architecture

• N-Tier Architectural Design
• Service Oriented Architecture Fundamentals
• Component Oriented Development Fundamentals
• Enterprise Services/COM Fundamentals
• MSMQ Fundamentals
• Web Service/WS-* Fundamentals
• RSS/Atom Fundamentals
• WCF Fundamentals (Address, Binding, Contract)

Data

• Set Theory Fundamentals
• Database Design/Data Modeling Mastery
• ACID and Normalization Concepts
• SQL Server 2005/2008 Interaction Familiarity
• SQL Server 2005/2008  Query Optimization
• SQL Server 2005/2008  Index Design
• SQL Server 2005/2008  Tuning
• T-SQL Proficiency
• O/R Mapper Familiarity
• XML/DTD/XSD/XSLT/XPath Fundamentals

System Technologies

• Windows Server 2003/2008 Familiarity
• IIS 6.0/7.0/7.5 Proficiency
• Component Services (COM+) Familiarity (the tool)
• TCP/IP Fundamentals (Basic IP Theory, DNS, ping, tracert)
• Networking Fundamentals (Routers, Switches, DHCP Servers)
• Web Server Farm Fundamentals
• 'Run' Window Proficiency
• Batch File Fundamentals
• Windows Client Proficiency (Network Mapping, File Operations)

General Software Development

• Software Development Life Cycle Fundamentals
• Iterative/Agile/Waterfall/MSF Familiarization
• Version Control Familiarity (CVS, Subversion, etc)

Quality Assurance

• NUnit Familiarity
• Unit/Regression Testing Familiarity
• Profiling Fundamentals

General

• College Algebra Proficiency
• Statistics Fundamentals (probabilities mainly)
• Calculus Theory Fundamentals (rates of change fundamentals)
• Cryptography Fundamentals (asymmetrical, hash, checksum)
• Proper English Grammar (who vs. whom, etc)
• Solid Spelling Skills

Attitude

• Results Focused Attitude
• Vision Oriented (mainly for Architects and Team Leads)
• Paradigm Shifting Abilities
• Unlearning Abilities (the ability to unlearn obsolete paradigms)
• High Standards ("takes pride in his or her work")
• Unbiased to Vendors (i.e. doesn't say Microsoft SUCKS! or Linux blows!)

Ethics

• Patience for Technology and Other People
• Strong Ethical Nature (Honest, Trustworthy)
• Common Sense Sexual Harassment Law Adherence (a.k.a. maturity)
• Common Sense Use of Proper Language In and Around the Work Place (a.k.a. maturity)
• Common Sense Politics/Religious Respect
• Work Place Software Piracy Law Adherence
• Gender Neutral Language Guideline Adherence (mainly in documentation and professional correspondence)

Delegates in C#

Delegates is a type that reference Method. When it assigned by a method it behaves exactly same as that method. It can be used as parameters and can be returned a value. So it has same what are the methods have.

Delegates makes is possible to programmatically change method calls, and plug new codes in to existing classes. For these you need to know what are the method matches delegate’s signature and its return type. Delegates are similar to C++ function pointers but delegates type safe and Object Oriented. Methods don’t need to match the delegate signature exactly.

What is Covariance and Contravariance in Delegates ?

Covariance and Contravariance provides kind of flexibility when matching the method signature with delegate type that is defined.

Covariance permits a method to have a more derived return type than what is defined when the delegate define. Contravariance permits a method to have less derived parameter types than in the delegate type.

A delegate is a type it encapsulates a method see below example:

        // Define the Delegate

        public delegate void TestDelegate(string Message);

        // Creating a method with string argument

        public static void DisplayMessage(string Message)

        {

            Console.WriteLine(Message);

            Console.ReadKey(); 

        }

        static void Main(string[] args)

        {

            // Instantiate the delegate and encapsulates the method "DisplayMessage"

            TestDelegate Test = DisplayMessage;

            // call the delegate

            Test("This is my delegate method");

        }

 This is very simple example but delegate can used in advance way rather this. The instantiated delegate is an object, it can be passed as parameter, or assign to a property. When a delegate is use in this way the code using by the delegate does not need any knowledge of the method being used. This is similar functionality provide by interface encapsulation.

What is Multicasting?

In a delegate you can have more than one method to invoke, you can assign method to a delegate using “=” and you can add method to a delegate where it has assigned a method to invoke by using “+” if you want you can remove assigned method from a delegate where it has more methods to invoke by using “-“. This is called as multicasting.

Multicasting example:

namespace Delegates_Test2

{

    delegate void Del();

    class Simple

    {

        public void MethodA()

        {

            System.Console.WriteLine("Message from the method A.");

        }

        static public void MethodB()

        {

            System.Console.WriteLine("Message from the method B.");

        }

    }

}

 namespace Delegates_Test2

{

    class Program

    {

        static void Main(string[] args)

        {

            Simple sc = new Simple();

            // Map delegate to the method: A

            Del d = sc.MethodA;

         

            // Map method: B with multicasting

            d += Simple.MethodB;

           

            d(); // Both methods are excute here

            Console.ReadKey(); 

        }

    }

}

Generic Delegates

The delegate can define its own generic type parameters.

How to define:

public delegate void MyDelegate<T>(T item);

Generic delegate example:

namespace Generic_Delegate

{

    //Generic Delegate define here with return value of T, and both T arguments

    public delegate T Calculator<T> (T arg1, T arg2);

    class MathUtility

    {

    

    // Generic method to execute with Two generic argument values and one generic  methods  

        public static void Calculate<T>(T[] values1, T[] values2, Calculator<T> t)

        {

            for (int i=0; i < values1.Length; i++)

            {   // execute the T method with two of T arguments

                values1[i] = t(values1[i],values2[i]);

                //And assigning results to First parameter

     

            }

        }

    }

}

namespace Generic_Delegate

{

    class Program

    {

        // My method to find  square value

        static int FindSquareValue(int x, int y)

        {

            // Your method's implementation

            return (x * y); // Your method have defined to return the results

        }

        // My Method to find dividence with first value by second value

        static double FindDividence(double a, double b)

        {

            // Your method's implementation

            return (a / b);  // Your method have defined to return the results

        }

          

        static void Main(string[] args)

        {

            // To get Square

            int[] height = { 10, 5, 8 };

            int[] width = { 4, 3, 6 };

            MathUtility.Calculate(height, width, FindSquareValue); // Dynamically hook with

                                                                   // FindSquare method

            // You're only passing the both values and method

          

            Console.WriteLine("Display Square Values..."); 

           

            foreach (int i in height)

            {

                Console.WriteLine(i.ToString());   

            }

    

           // To get Dividence

            double[] Val1 = { 10, 80, 60 };

            double[] val2 = {8,3,4};

            MathUtility.Calculate(Val1, val2, FindDividence);

            Console.WriteLine("Display Dividence values..."); 

            foreach (double d in Val1)

            {

                Console.WriteLine(d.ToString());  

            }

            Console.ReadKey(); 

        }

    }

}

Hope this documentation may valuable for you!!