
p.location-badge.
  exported from <a href='../di'>angular2/di</a>
  defined in <a href="https://github.com/angular/angular/tree/3a0410a/modules/angular2/src/di/binding.ts#L34-L255">angular2/src/di/binding.ts (line 34)</a>

:markdown
  Describes how the <a href='Injector-class.html'><code>Injector</code></a> should instantiate a given token.
  
  See <a href='bind-function.html'><code>bind</code></a>.
  
  ## Example
  
  ```javascript
  var injector = Injector.resolveAndCreate([
    new Binding(String, { toValue: 'Hello' })
  ]);
  
  expect(injector.get(String)).toEqual('Hello');
  ```
  
.l-main-section
  h2 Members
  .l-sub-section
    h3 constructor

    
    pre.prettyprint
      code.
        constructor(token, {toClass, toValue, toAlias, toFactory, toAsyncFactory, deps}: {
        toClass?: Type,
        toValue?: any,
        toAlias?: any,
        toFactory?: Function,
        toAsyncFactory?: Function,
        deps?: List&lt;any&gt;
      })
    
    :markdown
      
      




  .l-sub-section
    h3 token

    
    :markdown

      Token used when retrieving this binding. Usually the `Type`.
      
      





  .l-sub-section
    h3 toClass

    
    :markdown

      Binds an interface to an implementation / subclass.
      
      
      
      Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy
      comparison.
      
      ```javascript
      
      class Vehicle {}
      
      class Car extends Vehicle {}
      
      var injectorClass = Injector.resolveAndCreate([
        Car,
        new Binding(Vehicle, { toClass: Car })
      ]);
      var injectorAlias = Injector.resolveAndCreate([
        Car,
        new Binding(Vehicle, { toAlias: Car })
      ]);
      
      expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
      
      expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
      ```
      
      





  .l-sub-section
    h3 toValue

    
    :markdown

      Binds a key to a value.
      
      
      
      ```javascript
      var injector = Injector.resolveAndCreate([
        new Binding(String, { toValue: 'Hello' })
      ]);
      
      expect(injector.get(String)).toEqual('Hello');
      ```
      
      





  .l-sub-section
    h3 toAlias

    
    :markdown

      Binds a key to the alias for an existing key.
      
      An alias means that <a href='Injector-class.html'><code>Injector</code></a> returns the same instance as if the alias token was used.
      This is in contrast to `toClass` where a separate instance of `toClass` is returned.
      
      
      
      Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy
      comparison.
      
      ```javascript
      
      class Vehicle {}
      
      class Car extends Vehicle {}
      
      var injectorAlias = Injector.resolveAndCreate([
        Car,
        new Binding(Vehicle, { toAlias: Car })
      ]);
      var injectorClass = Injector.resolveAndCreate([
        Car,
        new Binding(Vehicle, { toClass: Car })
      ]);
      
      expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
      expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
      
      expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
      expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
      ```
      
      





  .l-sub-section
    h3 toFactory

    
    :markdown

      Binds a key to a function which computes the value.
      
      
      
      ```javascript
      var injector = Injector.resolveAndCreate([
        new Binding(Number, { toFactory: () => { return 1+2; }}),
        new Binding(String, { toFactory: (value) => { return "Value: " + value; },
                              dependencies: [Number] })
      ]);
      
      expect(injector.get(Number)).toEqual(3);
      expect(injector.get(String)).toEqual('Value: 3');
      ```
      
      





  .l-sub-section
    h3 toAsyncFactory

    
    :markdown

      Binds a key to a function which computes the value asynchronously.
      
      
      
      ```javascript
      var injector = Injector.resolveAndCreate([
        new Binding(Number, { toAsyncFactory: () => {
          return new Promise((resolve) => resolve(1 + 2));
        }}),
        new Binding(String, { toFactory: (value) => { return "Value: " + value; },
                              dependencies: [Number]})
      ]);
      
      injector.asyncGet(Number).then((v) => expect(v).toBe(3));
      injector.asyncGet(String).then((v) => expect(v).toBe('Value: 3'));
      ```
      
      The interesting thing to note is that event though `Number` has an async factory, the `String`
      factory function takes the resolved value. This shows that the <a href='Injector-class.html'><code>Injector</code></a> delays
      executing the
      `String` factory
      until after the `Number` is resolved. This can only be done if the `token` is retrieved using
      the `asyncGet` API in the <a href='Injector-class.html'><code>Injector</code></a>.
      
      





  .l-sub-section
    h3 dependencies

    
    :markdown

      Used in conjunction with `toFactory` or `toAsyncFactory` and specifies a set of dependencies
      (as `token`s) which should be injected into the factory function.
      
      
      
      ```javascript
      var injector = Injector.resolveAndCreate([
        new Binding(Number, { toFactory: () => { return 1+2; }}),
        new Binding(String, { toFactory: (value) => { return "Value: " + value; },
                              dependencies: [Number] })
      ]);
      
      expect(injector.get(Number)).toEqual(3);
      expect(injector.get(String)).toEqual('Value: 3');
      ```
      
      





  .l-sub-section
    h3 resolve

    
    pre.prettyprint
      code.
        resolve()
    
    :markdown

      Converts the <a href='Binding-class.html'><code>Binding</code></a> into <a href='ResolvedBinding-class.html'><code>ResolvedBinding</code></a>.
      
      <a href='Injector-class.html'><code>Injector</code></a> internally only uses <a href='ResolvedBinding-class.html'><code>ResolvedBinding</code></a>, <a href='Binding-class.html'><code>Binding</code></a> contains
      convenience binding syntax.
      
      




