- Me

var X = "window";

function outermost() {
    var Y = "outermost";

    function inner() {
        // Knows about the parent function's Y
        alert(Y);

        function innermost() {
            // Knows about the grandparent function's Y
            alert(Y);
            // Knows about the greatgrandparent's X
            alert(X);
        }
        innermost();
    }
    inner();
}
outermost();

This seems simple enough, even expected. Now here’s the trick, let’s return some function pointers,

var X = "window";

function outermost() {
    var Y = "outermost";

    function inner() {
        // Knows about the parent function's Y
        alert(Y);

        function innermost() {
            // Knows about the grandparent function's Y
            alert(Y);
            // Knows about the greatgrandparent's X
            alert(X);
        }

        // 'inner' returns a reference to the 'innermost' function
        return innermost;
    }

    // 'outermost' returns a reference to the 'inner' function
    return inner;
}

Now let’s call these functions,

// Get the reference to the 'inner' function
var inr = outermost();

// Call the 'inner' function
inr();  // alerts 'outermost'

// Get the reference to the innermost function
var inmost = inr(); // alerts 'outermost'

// Call the 'innermost' function
inmost();   // alerts 'outermost' and 'window'

As you can see, when we call the ‘innermost’ function, using the reference returned by the call to ‘inner’, it still has access to the X and Y values as they were in scope when the ‘innermost’ function was defined. This is Javascript’s closure – capturing information at the point of definition, so that the information can be used at the point of execution. Also the variables are not copies – they are references.

A very common problem that occurs is in the unintended creation of closure,

for (var i = 0; i < 5; i++) {
    // This creates a closure!
    elements[i].onclick = function() { alert(i); };
}

Now clicking on any element will alert ‘4’, why? Because all of the functions we created have a reference (not a copy) to the outer var i, probably not the effect you want. To fix this,

for (var i = 0; i < 5; i++) {
    // Don't create a function - no closure
    elements[i].onclick = Handle(i);
}

function Handle(i) {
    return function() { alert(i); };
}

You can read up more about closures here.

// The base class
function Base() {
    // Public property
    this.aPublicProperty = "This is a public property of the type Base";
}

This initializes the prototype property (internally) to an empty class.

// 'prototype' is not null, it is initialized internally like this - Base.prototype = { }
alert(Base.prototype);   // [object Object]

Now we can add fields/properties to the (empty) object that the prototype refers,

// Add a new field/property
Base.prototype.newField = "This is a new field of the type Base's prototype";
Base.prototype.aPublicProperty = "This is a public property of the type Base's prototype";

Now here’s the trick that transforms this innocuous looking property into the basis of Javascript’s object oriented implementation: when you access a property on a class, if the class doesn’t have the property, Javascript will look for the property on the object the prototype refers to. Now we can see how this might lead to inheritance – the derived class (the object) can access the base class’s (the object’s prototype’s object) methods. Also if both the object and the object’s prototype referred object have the same property, the object’s property overrides the prototype referred object’s property.

var baseInstance = new Base();
alert(baseInstance.newField);        // Access the prototype's property
alert(baseInstance.constructor.prototype.aPublicProperty);  // Access the prototype's property - will see later
alert(Base.prototype.aPublicProperty);  // Access the prototype's property via Base
alert(baseInstance.aPublicProperty);    // Override the prototype's property

We are starting to see object-oriented behaviors implemented via the prototype property. The prototype property refer’s to the object’s base class. Let’s take this further,

// Derived from the base class
function Derived() { }
Derived.prototype = new Base();

// Another class derived from the base class
function AnotherDerived() { }
AnotherDerived.prototype = new Base();

// A class derived from the derived class
function DerivedDerived() { }
DerivedDerived.prototype = new Derived();

This results in a class hierarchy that looks like this,

Now that we have the class structure, let’s create some instances,

// Create some instances
var derivedInstance = new Derived();
var anotherDerivedInstance = new AnotherDerived();
var derivedDerivedInstance = new DerivedDerived();

Let’s add a new property to the Base’s prototype.

// Add a new property to the Base's prototype
Base.prototype.testInheritance = "Every object that derives from Base now has this property";
alert(derivedDerivedInstance.testInheritance);

And add a new property to the Derived’s prototype,

// Add a new property to the Derived's prototype
Derived.prototype.testInheritance = "Every object that derives from Derived now has this property";
// Does that mean the Base now has the property? No.
alert(baseInstance.testInheritance); // undefined
alert(derivedDerivedInstance.testInheritance);

For more information about Javascript prototypes see here.

// A string literal
var stringLiteral = "A string literal";

// An array literal
var arrayLiteral = [1,2,3];

Extending this concept to objects, we create an anonymous type in Javascript using an object literal,

// Create an anonymous type by using the object literal notation,
var myObjectUsingJSON = {

    // Public field – a name/value pair
    aPublicField : "This is a public field of an anonymous type",

    // Public method – another name/value pair
    aPublicMethod : function() { return this.aPublicField; }
}

// Call the anonymous type’s public field or method
alert(myObjectUsingJSON.aPublicMethod()); 

We created an instance (myObjectUsingJSON) of the the anonymous type using the object literal notation and the anonymous object has two members which are name-value pairs. This way of representing (and creating) an object is called the Javascript Object Notation or JSON. It’s just a way of creating an anonymous type using name-value pairs. For comparison, recall how we similarly create anonymous types in C#,

// Anonymous type in C#
var anonType = new { Name = "John", Age = 50 };

Now let’s create a more complicated class using this object notation,

// Create an anonymous type...
var myObjectUsingJSON = {

    // ...with a key whose value is a simple array...
    anArray : ["This", "array", "has", 5, "items"],

    // ...and another key whose value is an array with a nested object...
    anotherArray : ["This", "array", "has", 6, { X: 1 }, "items"],

    // ...and another key whose value happens to be another anonymous object...
    anObject : {
        key1 : "A string",                           /* ...with one key whose value is a string... */
        key2 : function() { return "Hello"; },       /* ...and another key whose value is a function... */
        key3 : {                                     /* ...and another key whose value happens to be another anonymous object */
            key31 : true,                            /* ...with a key whose value is a boolean... */
            key32 : function() { return { Name: "World!" }; }, /* ...and a key whose value is a function that returns an object */
            key33 : {                                          /* This key's value happens to get yet another anonymous object */
                key331 : function() { return "That’s deep!"; }
            }
        }
    }
}

// Access an array element
alert(myObjectUsingJSON.anArray[2]);

// Access the inner object
alert(myObjectUsingJSON.anotherArray[4].X);

// Get a value from a name
alert(myObjectUsingJSON.anObject.key3.key31);

// Access the object returned by the function
var funcReturn = myObjectUsingJSON.anObject.key3.key32();
alert(funcReturn.Name);

// Call the deepest function
alert(myObjectUsingJSON.anObject.key3.key33.key331());

As you can see it’s pretty easy to nest anonymous objects to create a class structure. This representation of a class is more compact than XML, in terms of raw serialized bytes sent over the wire. So, Javascript prefers using this object notation when sending/receiving data. A string can easily be eval-ed into an object,

// The JSON string
var jsonString = "{ anotherArray: ['This', 'array', 'has', 6, { X: 1 }, 'items'] }";

// Eval the JSON string into an object
var myEvaledJSONObject = eval('(' + jsonString + ')');

// Access the object
alert(myEvaledJSONObject.anotherArray[4].X);

For more information about JSON see here.

// Define the derived function (remember there is no 'class' keyword in Javascript)
function MyDerivedClass() { }

// Derive from MyClass, equivalent to –> public class MyDerivedClass : MyClass
MyDerivedClass.prototype = new MyClass();

// Create an instance of the derived class
var myderivedClass = new MyDerivedClass();

// Get the public field
alert(myderivedClass.aPublicField);

// Call the public method
alert(myderivedClass.aPublicMethod());

Woah! That was simple! Notice that MyClass’s private methods and the runtime field (aRuntimeField) we gave to MyClass in the last post is not available to MyDerivedClass.

Let’s override the base classe’s public fields and methods and see what happens,

// Define the derived function (remember there is no 'class' keyword in Javascript
function MyDerivedClass() {

    // Override the base's public field
    this.aPublicField = "This is a public field of the type MyDerivedClass";

    // Override the base's public method
    this.aPublicMethod = function() { return this.aPublicField; }
}

// Derive from MyClass, equivalent to –> public class MyDerivedClass : MyClass
MyDerivedClass.prototype = new MyClass();

// Create an instance of the derived class
var myderivedClass = new MyDerivedClass();

// Get the public field
alert(myderivedClass.aPublicField);

// Call the public method
alert(myderivedClass.aPublicMethod());

You’ll see that the base classes public fields and methods have been overridden in the derived class.

We can obviously derive again,

// Derive from MyDerivedClass
function MyDerivedDerivedClass() {

    // Override the base's public field
    this.aPublicField = "This is a public field of the type MyDerivedDerivedClass";

    // Override the base's public method
    this.aPublicMethod = function() { return this.aPublicField; }
}

// Derive from MyDerivedClass, equivalent to –> public class MyDerivedDerivedClass : MyDerivedClass
MyDerivedDerivedClass.prototype = new MyDerivedClass();

// Create an instance of the derived class
var myderivedderivedClass = new MyDerivedDerivedClass();

// Call the public method
alert(myderivedderivedClass.aPublicField);

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
    <head>
        <title>Hello Javascript!</title>
        <script type="text/javascript" src="MyScript.js"></script>
    </head>
    <body>
        Hello Javascript!
    </body>
</html>

Now let’s create a class definition (in MyScript.js). Note that there is no ‘class’ keyword in Javascript, the class definition is just a function definition,

function MyClass() {

    // Public field
    this.aPublicField = "This is a public field of the type MyClass";

    // Private field
    var aPrivateField = "This is a private field of the type MyClass";

    // Public method
    this.aPublicMethod = function() {
        // Use the private method
        if (aPrivateMethod()) { return this.aPublicField; }
        else { return aPrivateField; }
    }

    // Private method
    function aPrivateMethod() {
        return true;
    }

    // Oops! We can expose the private field
    this.exposePrivateField = aPrivateField;
    // and the private method
    this.exposePrivateMethod = aPrivateMethod;
}

// Create an instance of MyClass using the ‘new’ keyword
var myclass = new MyClass();

// Get the public field
alert(myclass.aPublicField);

// Call the public method
alert(myclass.aPublicMethod());

// Call the private field – can’t get to them directly
alert(myclass.exposePrivateField);
alert(myclass.exposePrivateMethod());

So it’s pretty simple to create a class in Javascript. We can also create a runtime field for the class,

// Create an instance of MyClass
var myclass = new MyClass();

// Create a field at runtime
myclass.aRuntimeField = "This is a runtime field of the type MyClass";

// View the field value
alert(myclass.aRuntimeField);

Javascript Concepts Simplified Part 1: Javascript Classes

Javascript Concepts Simplified Part 2: Javascript Inheritance

Javascript Concepts Simplified Part 3: Javascript and JSON

Javascript Concepts Simplified Part 4: The Prototype Property

Javascript Concepts Simplified Part 5: Javascript Closures

Using the browser you can view the source tree and folder/file history, checkin/checkout files,

View pending changes (even for other users) and checkin/undo your files,

You can view your (or other people’s) shelve sets,

You can also change the displayed user via the User’s tab.

You can compare file history,

and view change set details,

FAQs:

1. Make sure you have mapped correctly, ‘Not mapped’ will cause the exception,

TF10217: Team Foundation was unable to complete your request due to an unexpected error. For more details, see the event log on the Team Foundation Server.

1. SOAP 1.2: SOAP stands for Simple Object Access Protocol. It is simply an XML document that describes a message (structured and typed information) that can be sent from one network endpoint to another. SOAP is fundamentally a stateless, one-way message exchange paradigm, but applications can create more complex interaction patterns (e.g., request/response) by combining such one-way exchanges with features provided by an underlying protocol and/or application-specific information. A SOAP message may be transferred by different underlying protocols for example, for web-based access, it could be placed in the body of a HTTP POST request. The schema for the SOAP XML can be found here. The structure of a SOAP message looks like this,

<?xml version='1.0' ?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">

  <!-- The header is optional. It contains contextual information related to the message -->
  <soap:Header>
  </soap:Header>

  <!-- The body is mandatory -->
  <soap:Body>
    <!-- Sample content -->
    <ns:GetPassengerName xmlns:ns="http://someURI">
      <ns:PassengerId>815</ns:PassengerId>
    </ns:GetPassengerName>
  </soap:Body>

</soap:Envelope>

And another could look like,

<?xml version='1.0' ?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">

  <!-- The body is mandatory -->
  <soap:Body>
    <!-- The body has content -->
    <ns:GetPassengerNameResponse xmlns:ns="http://someURI">
      <ns:PassengerName>John Locke</ns:PassengerName>
    </ns:GetPassengerNameResponse>

    <!-- or can report a fault -->
    <soap:Fault>
      <soap:Code>
      </soap:Code>
      <soap:Reason>
      </soap:Reason>
      <soap:Detail>
      </soap:Detail>
    </soap:Fault>
  </soap:Body>
</soap:Envelope>

The above example is a little contrived, it’s recommended that you use URIs as resource identifiers, so your host might look like http://someHOST/somePATH?PassengerNameFromID=815.

The SOAP-HTTP binding is of particular interest because it is widely used.

    a. SOAP HTTP GET example,

GET /somePATH?PassengerNameFromID=815 HTTP/1.1
Host: someHOST
Accept: text/html;q=0.9, application/soap+xml

with a response,

HTTP/1.1 200 OK
Content-Type: application/soap+xml; charset="utf-8"
Content-Length: [...]

<?xml version='1.0' ?>
<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope">
  <env:Body>[...]</env:Body>
</env:Envelope>

    b. SOAP HTTP POST example,

POST /somePATH HTTP/1.1
Host: someHOST
Content-Type: application/soap+xml; charset="utf-8"
Content-Length: [...]

<?xml version='1.0' ?>
<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope" >
  <env:Body>[...]</env:Body>
</env:Envelope>

2. WSDL 1.1: WSDL stands for Web Services Description Language. It is simply an XML document that describes a web service. The schema for the WSDL XML is publicly available here. The WSDL XML needs to describe fully how communication between two network endpoints will occur. It is a binding mechanism, it attaches a specific protocol or format to a message, operation or endpoint. The major parts of the WSDL XML are,

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="HelloService">

  <types>
    <!-- What data types are exchanged -->
  </types>

  <message>
    <!--What messages are exchanged -->
  </message>

  <portType>
    <!-- What operations are supported by the web service -->
  </portType>

  <binding>
    <!-- How the messages will be transmitted -->
  </binding>

  <service>
    <!-- Where is the web service located -->
  </service>

</definitions>

Say you have a service contract,

[ServiceContract]
public interface IService1 {
    [OperationContract]
    string GetData(int value);
}

The corresponding WSDL looks like (some things omitted for clarity),

<?xml version="1.0" encoding="utf-8"?>
<wsdl:definitions name="Service1" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" [...]>

  <!-- The two messages GetData and GetDataResponse (because IsOneWay is false) -->
  <wsdl:message name="IService1_GetData_InputMessage">
    <wsdl:part name="parameters" element="tns:GetData"/>
  </wsdl:message>
  <wsdl:message name="IService1_GetData_OutputMessage">
    <wsdl:part name="parameters" element="tns:GetDataResponse"/>
  </wsdl:message>

  <!-- The web service only has one operation - GetData -->
  <wsdl:portType name="IService1">
    <wsdl:operation name="GetData">
      <wsdl:input wsaw:Action="http://tempuri.org/IService1/GetData" message="tns:IService1_GetData_InputMessage"/>
      <wsdl:output wsaw:Action="http://tempuri.org/IService1/GetDataResponse" message="tns:IService1_GetData_OutputMessage"/>
    </wsdl:operation>
  </wsdl:portType>

  <!-- Note the WSHttpBinding -->
  <wsdl:binding name="WSHttpBinding_IService1" type="tns:IService1">
    <wsdl:operation name="GetData">
        <wsdl:input>
          <wsp:PolicyReference URI="#WSHttpBinding_IService1_GetData_Input_policy"/>
        </wsdl:input>
        <wsdl:output>
          <wsp:PolicyReference URI="#WSHttpBinding_IService1_GetData_output_policy"/>
        </wsdl:output>
      </wsdl:operation>
  </wsdl:binding>

  <!-- The address for the web service -->
  <wsdl:service name="Service1">
    <wsdl:port name="WSHttpBinding_IService1" binding="tns:WSHttpBinding_IService1">
      <wsa10:EndpointReference>
        <wsa10:Address>http://localhost:8731/Design_Time_Addresses/WcfServiceLibrary2/Service1/</wsa10:Address>
        <Identity xmlns="http://schemas.xmlsoap.org/ws/2006/02/addressingidentity">
          <Dns>localhost</Dns>
        </Identity>
      </wsa10:EndpointReference>
    </wsdl:port>
  </wsdl:service>

3. REST: REST stands for Representational State Transfer. REST is basically a set of design principles for web services. Since it’s not a protocol (like SOAP), it doesn’t specify any new XML or schema but relies on HTTP’s methods (GET/POST/PUT/DELETE). The idea is to design (REST-ful) web services that deal with identifying and manipulating resources using HTTP methods. is to use The four main tenets of REST are,

    a. Use HTTP methods correctly: This means use the methods GET/POST/PUT/DELETE for what they are meant for. For example, GET should be a safe retrieval with no side effects.

    b. Be Stateless: Design the host and client so that the HTTP headers and body of a request contains all of the parameters, context, and data needed by the server-side component to generate a response. A stateless service shifts most of the responsibility of maintaining state to the client application.

   c. Expose self-documenting (directory structure-like) URIs: For example, http://someHOST/photos/2010/05/27/{id}

   d. Use MIME types and HTTP Accept: RESt-ful services usually use the common content types application/json or application/xml.

1. Sessions: A session is a grouping of client requests. Unlike ASP.NET there is no data store associated with a WCF session. Not all bindings support sessions (BasicHttpBinding does not). Client applications initiate sessions and then receive and process the messages sent within the session. Messages delivered during a session are processed in the order in which they are received. When a WCF service accepts a client session, all calls between a WCF client object are handled by the same user-defined service object.

We can use the SessionMode attribute to require, allow, or prohibit bindings to use sessions between endpoints.

    a. Allowed: (default) If a service contract specifies that it allows sessions but does not require one, clients can connect and either establish a session or not establish a session.

    b. Required: When a service contract specifies that it requires a session, that contract is specifying that all calls must be part of the same conversation. The service contract requires a sessionful binding. An exception is thrown if the binding is not configured to support session (can’t use BasicHttpBinding). Creating a service contract that requires a session states that the group of operations that the service contract declares must all be executed within the same session and that messages must be delivered in order.

    c: NotAllowed: The service contract never supports bindings that initiate sessions.

2. Instance Management: The refers to how WCF manages your service class object instantiation (and disposal) depending on a client request, that is, managing the lifetime of the service instance. The possible values for InstanceContextMode are.

    a. PerCall: A new service object is created for each client request, that means that even if the same client is sending requests, a new service object is created for each request and disposed after the reply is sent. To see this, use a service like this,

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)]
public class Service1 : IService1 {
    Guid guid = Guid.NewGuid();

    public string GetGuid() {
        return guid.ToString();
    }
}

and a client like this,

for (int i = 0; i < 5; i++) {
    Console.WriteLine(proxy.GetGuid());
}

When a client calls the GetGuid method it will get a new Guid everytime, because the Service1 object is recreated after every reply.

    b. PerSession: (default) A new service object is created for each new client session and maintained for the lifetime of the session (applies to bindings that supports session like WSHttpBinsing). For BasicHttpBinding which doesn’t support sessions, its the same as PerCall. To see this, connect multiple clients to the host and each client will get a new Guid, Thus some state is maintained between requests from the same client.

    c. Single: A single service object handles all clients and client requests for the lifetime of the application. To see this. simply change the InstanceContextMode to InstanceContextMode.Single. Now every client and every client call will return the same Guid.

3. Concurrency: This refers to the number of threads executing at the same time in a service instance.

    a. Single: (default) One thread at a time can access the service object. The service object queues additional calls in the order it receives them. When the first call finishes, the next call in the queue locks the service. The benefit to this approach is that there is no risk of two calls reading the same memory and changing the same data. To see this try the service,

[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Single)]
public class Service1 : IService1 {

public void TestConcurrency() {
    Thread.Sleep(10000);
    return;
}

This says that there is a single service object and only one thread can access it. Running two clients against this host will result in,

Note that after the first client took 10sec but the second took 20sec.

  b. Reentrant. One thread at a time can access the service object but the thread can exit and reenter. This is useful if the service needs to make callbacks to the client.

    c. Multiple. More than one thread at a time can access the service object. The WCF runtime assigns a thread to each client call and they execute simultaneously. Its up to you to make the service thread safe. To see this, simply change the ConcurrencyMode to Multiple in the example above, now running two clients will result in both taking 10sec,

To see how sessions interact with instance management in more detail see here.