How to display ICollection in Postman ?

This is the code im working with . The MENUCATEGORY has a list of ITEMS. How to show that result on Postman , than when i write this url  http://localhost:49477/api/menucategories1/coffee   (for example:coffee is a categoryId)  and then to display json result all items in this category like machiato , americano and so on:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.Description;
using BarRestaurant.Models;

namespace BarRestaurant.Controllers
{
    public class MenuCategories1Controller : ApiController
    {
        private ApplicationDbContext db = new ApplicationDbContext();

        // GET: api/MenuCategories1
        public IQueryable<MenuCategory> GetMenuCategories()
        {
            return db.MenuCategories;
        }

        // GET: api/MenuCategories1/5
        [ResponseType(typeof(MenuCategory))]
        public IHttpActionResult GetMenuCategory(string id)
        {
            MenuCategory menuCategory = db.MenuCategories.Find(id);
            if (menuCategory == null)
            {
                return NotFound();
            }

            return Ok(menuCategory);
        }

        // PUT: api/MenuCategories1/5
        [ResponseType(typeof(void))]
        public IHttpActionResult PutMenuCategory(string id, MenuCategory menuCategory)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != menuCategory.MenuCategoryID)
            {
                return BadRequest();
            }

            db.Entry(menuCategory).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!MenuCategoryExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        // POST: api/MenuCategories1
        [ResponseType(typeof(MenuCategory))]
        public IHttpActionResult PostMenuCategory(MenuCategory menuCategory)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            db.MenuCategories.Add(menuCategory);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateException)
            {
                if (MenuCategoryExists(menuCategory.MenuCategoryID))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtRoute("DefaultApi", new { id = menuCategory.MenuCategoryID }, menuCategory);
        }

        // DELETE: api/MenuCategories1/5
        [ResponseType(typeof(MenuCategory))]
        public IHttpActionResult DeleteMenuCategory(string id)
        {
            MenuCategory menuCategory = db.MenuCategories.Find(id);
            if (menuCategory == null)
            {
                return NotFound();
            }

            db.MenuCategories.Remove(menuCategory);
            db.SaveChanges();

            return Ok(menuCategory);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }

        private bool MenuCategoryExists(string id)
        {
            return db.MenuCategories.Count(e => e.MenuCategoryID == id) > 0;
        }
    }
}




























using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.Description;
using BarRestaurant.Models;

namespace BarRestaurant.Controllers
{
    public class Items1Controller : ApiController
    {
        private ApplicationDbContext db = new ApplicationDbContext();

        // GET: api/Items1
        public IQueryable<Item> GetItems()
        {
            return db.Items;
        }

        // GET: api/Items1/5
        [ResponseType(typeof(Item))]
        public IHttpActionResult GetItem(string id)
        {
            Item item = db.Items.Find(id);
            if (item == null)
            {
                return NotFound();
            }

            return Ok(item);
        }

        // PUT: api/Items1/5
        [ResponseType(typeof(void))]
        public IHttpActionResult PutItem(string id, Item item)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != item.ItemID)
            {
                return BadRequest();
            }

            db.Entry(item).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ItemExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        // POST: api/Items1
        [ResponseType(typeof(Item))]
        public IHttpActionResult PostItem(Item item)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            db.Items.Add(item);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateException)
            {
                if (ItemExists(item.ItemID))
                {
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtRoute("DefaultApi", new { id = item.ItemID }, item);
        }

        // DELETE: api/Items1/5
        [ResponseType(typeof(Item))]
        public IHttpActionResult DeleteItem(string id)
        {
            Item item = db.Items.Find(id);
            if (item == null)
            {
                return NotFound();
            }

            db.Items.Remove(item);
            db.SaveChanges();

            return Ok(item);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }

        private bool ItemExists(string id)
        {
            return db.Items.Count(e => e.ItemID == id) > 0;
        }
    }
}





























using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace BarRestaurant.Models
{
    public class Item
    {

        //
        public string ItemID { get; set; }
        [ForeignKey("MenuCategory")]

        public string MenuCategoryID { get; set; }


        public string ShortDescription { get; set; }

        public string Name { get; set; }


        public Decimal Price { get; set; }


        public virtual MenuCategory MenuCategory { get; set; }




    }
}















using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace BarRestaurant.Models
{
    public class MenuCategory
    {

        public MenuCategory()
        {

            this.Items = new HashSet<Item>();

        }

        //
        public string MenuCategoryID { get; set; }
        [ForeignKey("Local")]

        public string LocalID { get; set; }

        public string Image { get; set; }



        public string Name { get; set; }


        public virtual Local Local{ get; set; }

        public virtual ICollection<Item> Items { get; set; }



    }
}
















CREATE TABLE [dbo].[MenuCategories] (
    [MenuCategoryID] NVARCHAR (128) NOT NULL,
    [KafiqID]        NVARCHAR (128) NULL,
    [Image]          NVARCHAR (MAX) NULL,
    [Name]           NVARCHAR (MAX) NULL,
    CONSTRAINT [PK_dbo.MenuCategories] PRIMARY KEY CLUSTERED ([MenuCategoryID] ASC),
    CONSTRAINT [FK_dbo.MenuCategories_dbo.Kafiqs_KafiqID] FOREIGN KEY ([KafiqID]) REFERENCES [dbo].[Kafiqs] ([KafiqID])
);


GO
CREATE NONCLUSTERED INDEX [IX_KafiqID]
    ON [dbo].[MenuCategories]([KafiqID] ASC);






























CREATE TABLE [dbo].[Items] (
    [ItemID]           NVARCHAR (128)  NOT NULL,
    [MenuCategoryID]   NVARCHAR (128)  NULL,
    [ShortDescription] NVARCHAR (MAX)  NULL,
    [Name]             NVARCHAR (MAX)  NULL,
    [Price]            DECIMAL (18, 2) NULL,
    CONSTRAINT [PK_dbo.Items] PRIMARY KEY CLUSTERED ([ItemID] ASC),
    CONSTRAINT [FK_dbo.Items_dbo.MenuCategories_MenuCategoryID] FOREIGN KEY ([MenuCategoryID]) REFERENCES [dbo].[MenuCategories] ([MenuCategoryID])
);


GO
CREATE NONCLUSTERED INDEX [IX_MenuCategoryID]
    ON [dbo].[Items]([MenuCategoryID] ASC);