c# does not contain a definition for and no extension method
<p>my code: </p>

<pre><code>using UnityEngine;
using System.Collections;

[RequireComponent(typeof(Controller2D))]
public class Player : MonoBehaviour
{

    public float jumpHeight = 4;
    public float timeToJumpApex = .4f;
    float accelerationTimeAirborne = .2f;
    float accelerationTimeGrounded = .1f;
    float moveSpeed = 6;

    float gravity;
    float jumpVelocity;
    Vector3 velocity;
    float velocityXSmoothing;

    Controller2D controller;

    void Start()
    {
        controller = GetComponent&lt;Controller2D&gt;();

        gravity = -(2 * jumpHeight) / Mathf.Pow(timeToJumpApex, 2);
        jumpVelocity = Mathf.Abs(gravity) * timeToJumpApex;
        print("Gravity: " + gravity + "  Jump Velocity: " + jumpVelocity);
    }

    void Update()
    {

        if (controller.collisions.above || controller.collisions.below)
        {
            velocity.y = 0;
        }

        Vector2 input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));

        if (Input.GetKeyDown(KeyCode.Space) &amp;&amp; controller.collisions.below)
        {
            velocity.y = jumpVelocity;
        }

        float targetVelocityX = input.x * moveSpeed;
        velocity.x = Mathf.SmoothDamp(velocity.x, targetVelocityX, ref velocityXSmoothing, (controller.collisions.below) ? accelerationTimeGrounded : accelerationTimeAirborne);
        velocity.y += gravity * Time.deltaTime;
        controller.Move(velocity * Time.deltaTime);
    }
}
</code></pre>

<p>Controller2D code:</p>

<p>using UnityEngine;
using System.Collections;</p>

<p>[RequireComponent(typeof(BoxCollider2D))]
public class Controller2D : MonoBehaviour
{</p>

<pre><code>public LayerMask collisionMask;

const float skinWidth = .015f;
public int horizontalRayCount = 4;
public int verticalRayCount = 4;

float horizontalRaySpacing;
float verticalRaySpacing;

new BoxCollider2D collider;
RaycastOrigins raycastOrigins;
internal object collisions;

void Start()
{
    collider = GetComponent&lt;BoxCollider2D&gt;();
    CalculateRaySpacing();
}

public void Move(Vector3 velocity)
{
    UpdateRaycastOrigins();
    if (velocity.x != 0)
    {
        HorizontalCollisions(ref velocity);
    }
    if (velocity.y != 0)
    {
        VerticalCollisions(ref velocity);
    }

    transform.Translate(velocity);
}

void HorizontalCollisions(ref Vector3 velocity)
{
    float directionX = Mathf.Sign(velocity.x);
    float rayLength = Mathf.Abs(velocity.x) + skinWidth;

    for (int i = 0; i &lt; horizontalRayCount; i++)
    {
        Vector2 rayOrigin = (directionX == -1) ? raycastOrigins.bottomLeft : raycastOrigins.bottomRight;
        rayOrigin += Vector2.up * (horizontalRaySpacing * i);
        RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, collisionMask);

        Debug.DrawRay(rayOrigin, Vector2.right * directionX * rayLength, Color.red);

        if (hit)
        {
            velocity.x = (hit.distance - skinWidth) * directionX;
            rayLength = hit.distance;
        }
    }
}

void VerticalCollisions(ref Vector3 velocity)
{
    float directionY = Mathf.Sign(velocity.y);
    float rayLength = Mathf.Abs(velocity.y) + skinWidth;

    for (int i = 0; i &lt; verticalRayCount; i++)
    {
        Vector2 rayOrigin = (directionY == -1) ? raycastOrigins.bottomLeft : raycastOrigins.topLeft;
        rayOrigin += Vector2.right * (verticalRaySpacing * i + velocity.x);
        RaycastHit2D hit = Physics2D.Raycast(rayOrigin, Vector2.up * directionY, rayLength, collisionMask);

        Debug.DrawRay(rayOrigin, Vector2.up * directionY * rayLength, Color.red);

        if (hit)
        {
            velocity.y = (hit.distance - skinWidth) * directionY;
            rayLength = hit.distance;
        }
    }
}

void UpdateRaycastOrigins()
{
    Bounds bounds = collider.bounds;
    bounds.Expand(skinWidth * -2);

    raycastOrigins.bottomLeft = new Vector2(bounds.min.x, bounds.min.y);
    raycastOrigins.bottomRight = new Vector2(bounds.max.x, bounds.min.y);
    raycastOrigins.topLeft = new Vector2(bounds.min.x, bounds.max.y);
    raycastOrigins.topRight = new Vector2(bounds.max.x, bounds.max.y);
}

void CalculateRaySpacing()
{
    Bounds bounds = collider.bounds;
    bounds.Expand(skinWidth * -2);

    horizontalRayCount = Mathf.Clamp(horizontalRayCount, 2, int.MaxValue);
    verticalRayCount = Mathf.Clamp(verticalRayCount, 2, int.MaxValue);

    horizontalRaySpacing = bounds.size.y / (horizontalRayCount - 1);
    verticalRaySpacing = bounds.size.x / (verticalRayCount - 1);
}

struct RaycastOrigins
{
    public Vector2 topLeft, topRight;
    public Vector2 bottomLeft, bottomRight;
}
</code></pre>

<p>}</p>

<p>When I hover over "above" and "below" it give me the error </p>

<blockquote>
  <p>c# does not contain a definition for and no extension method, </p>
</blockquote>

<p>can anyone see what I have done wrong? </p>