Repositer design patten write in unitofwork within dataacess layer

#region Using Namespaces...

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Data.Entity.Validation;
using DataModel.GenericRepository;
using BusinessEntities;

#endregion

namespace DataModel.UnitOfWork
{
    /// <summary>
    /// Unit of Work class responsible for DB transactions
    /// </summary>
    public class UnitOfWork : IDisposable
    {
        #region Private member variables...

        private KenCommerceEntities _context = null;
        //private GenericRepository<User> _userRepository;
        //private GenericRepository<Product> _productRepository;
        //private GenericRepository<Token> _tokenRepository;
        #region Company Barnding
        private GenericRepository<Banner> _bannerRepository;
        private GenericRepository<Informal> _InformalRepository;
        private GenericRepository<TopMenu> _TopMenuRepository;
        #endregion
        private GenericRepository<ItemType> _ItemTypeRepository;
        private GenericRepository<CategoryAttributeDtls> _ItemTypeDtlsRepository;
        private GenericRepository<Catalog> _catalogRepository;
        private GenericRepository<Category> _categoryRepository;
        private GenericRepository<Items> _itemsRepository;
        private GenericRepository<Options> _optionsRepository;
        private GenericRepository<Control> _controlRepository;
        private GenericRepository<ItemDetail> _itemDetailRepository;
        private GenericRepository<BaseAttribute> _baseAttributeRepository;
        private GenericRepository<Relevent_Images> _Relevent_ImagesRepository;
        private GenericRepository<Scheme> _schemeRepository;
        private GenericRepository<SchemeTermsAndCondition> _schemeTermsAndConditionRepository;
        private GenericRepository<Event> _eventRepository;
        private GenericRepository<SchemeType> _schemetypeRepository;
        private GenericRepository<UserFeedback> _UserFeedbackRepository;
        private GenericRepository<Auction> _auctionRepository;
        private GenericRepository<Auction_Item_Details> _auctionItemRepository;
        private GenericRepository<Auction_Item_Bid_History> _auctionItemBidRepository;
        private GenericRepository<ContactUs> _ContactUsRepository;
        private GenericRepository<ReasonForMail> _ReasonForMailRepository;
        private GenericRepository<City> _cityRepository;
        private GenericRepository<Country> _countryRepository;
        private GenericRepository<State> _stateRepository;
        private GenericRepository<EventDetails> _EventDetailsRepository;
        private GenericRepository<Commission> _CommissionRepository;
        private GenericRepository<Tax> _TaxRepository;
        private GenericRepository<CatalogImage_Details> _catalogimgaeRepository;
        private GenericRepository<ContactInfo> _contactInfoRepository;
        private GenericRepository<AboutUs> _AboutUsRepository;
        private GenericRepository<TermsCondition> _TermsConditionRepository;
        private GenericRepository<CatalogType> _CatalogTypeRepository;
        private GenericRepository<EventType> _EventTypeRepository;
        private GenericRepository<VenueType> _VenueTypeRepository;
        private GenericRepository<DisplaySection> _DisplaySectionRepository;
        private GenericRepository<DisplaySectionTable> _DisplaySectionTableRepository;
        private GenericRepository<Fequency> _FequencyRepository;
        private GenericRepository<ItemAttributeDetails>_ItemAttributeDetailsRepository;
        private GenericRepository<Support> _SupportRepository;
        private GenericRepository<Invoice> _InvoiceRepository;
        private GenericRepository<Payment> _PaymentRepository;
        private GenericRepository<OrderPlaced> _OrderPlacedRepository;
        private GenericRepository<TermsConditionGroup> _TermsandconditiongroupRepository;
        private GenericRepository<ShipmentDetails> _ShipmentDetailsRepository;
        private GenericRepository<Testimonial> _TestimonialRepository;
        private GenericRepository<HelpSupport> _HelpSupportRepository;
        private GenericRepository<Rating> _ratingRepository;
        private GenericRepository<DeliveryAddress> _DeliveryAddressRepository;
        private GenericRepository<WebProfile> _WebProfileRepository;
        private GenericRepository<WebContent> _WebContentRepository;
        private GenericRepository<ContactUsEnquiry> _contactUsEnquiryRepository;
        #region User
        private GenericRepository<Master_Login_User> _userRepository;
        private GenericRepository<UserRole> _userRoleRepository;
        private GenericRepository<Role> _roleRepository;
        private GenericRepository<RolePrevileges> _rolePrevilegesRepository;
        private GenericRepository<Feature> _featureRepository;
        #endregion

        #region Cart & CartDetails
        private GenericRepository<Cart> _cartRepository;
        private GenericRepository<CartDetails> _cartDetailsRepository;
        private GenericRepository<WishList> _wishListRepository;
        #endregion

        #region Menu & Submenu & Feature
        private GenericRepository<Menu> _menuRepository;
        private GenericRepository<SubMenu> _subMenuRepository;
        private GenericRepository<Feature> _FeatureRepository;
        #endregion

        #region Address
        private GenericRepository<User_Personal_Information> _UserPersonalInformationRepository;
        private GenericRepository<User_Banking_Information> _UserBankingInformationRepository;
        private GenericRepository<User_Additional_Information> _UserAdditionalInformationRepository;
        private GenericRepository<User_Address> _UserAddressRepository;
        #endregion

        #region Top and Middle Section
        private GenericRepository<TopSection> _TopSectionRepository;
        private GenericRepository<MiddleSection> _MiddleSectionRepository;
        private GenericRepository<MiddleSectionAllow> _MiddleSectionAllowRepository;
        private GenericRepository<DisplayTopMenu> __DisplayTopMenu;
        #endregion

        #region FAQ
        private GenericRepository<FAQ> _FAQRepository;
        private GenericRepository<FaqGroup> _FaqGroupRepository;
        private GenericRepository<FaqStatus> _FaqStatusRepository;
        #endregion
     

        #endregion

        public UnitOfWork()
        {
            _context = new KenCommerceEntities();
        }
       
        #region Public Repository Creation properties...
        public GenericRepository<ContactUsEnquiry> ContactUsEnquiryRepository
        {
            get
            {
                if (this._contactUsEnquiryRepository == null)
                    this._contactUsEnquiryRepository = new GenericRepository<ContactUsEnquiry>(_context);
                return _contactUsEnquiryRepository;
            }
        }
        public GenericRepository<DeliveryAddress> DeliveryAddressRepository
        {
            get
            {
                if (this._DeliveryAddressRepository == null)
                    this._DeliveryAddressRepository = new GenericRepository<DeliveryAddress>(_context);
                return _DeliveryAddressRepository;
            }
        }
        public GenericRepository<Rating> RatingRepository
        {
            get
            {
                if (this._ratingRepository == null)
                    this._ratingRepository = new GenericRepository<Rating>(_context);
                return _ratingRepository;
            }
        }
        public GenericRepository<Testimonial> TestimonialRepository
        {
            get
            {
                if (this._TestimonialRepository == null)
                    this._TestimonialRepository = new GenericRepository<Testimonial>(_context);
                return _TestimonialRepository;
            }
        }
        public GenericRepository<HelpSupport> HelpSupportRepository
        {
            get
            {
                if (this._HelpSupportRepository == null)
                    this._HelpSupportRepository = new GenericRepository<HelpSupport>(_context);
                return _HelpSupportRepository;
            }
        }
        public GenericRepository<Payment> PaymentRepository
        {
            get
            {
                if (this._PaymentRepository == null)
                    this._PaymentRepository = new GenericRepository<Payment>(_context);
                return _PaymentRepository;
            }
        }
        public GenericRepository<Invoice> InvoiceRepository
        {
            get
            {
                if (this._InvoiceRepository == null)
                    this._InvoiceRepository = new GenericRepository<Invoice>(_context);
                return _InvoiceRepository;
            }
        }
            public GenericRepository<TopMenu> TopMenuRepository
        {
            get
            {
                if (this._TopMenuRepository == null)
                    this._TopMenuRepository = new GenericRepository<TopMenu>(_context);
                return _TopMenuRepository;
            }
        }
        public GenericRepository<DisplayTopMenu> DisplayTopMenuRepository
        {
            get
            {
                if (this.__DisplayTopMenu == null)
                    this.__DisplayTopMenu = new GenericRepository<DisplayTopMenu>(_context);
                return __DisplayTopMenu;
            }
        }

        public GenericRepository<TermsConditionGroup> TermsandConditionGroupRepository
        {
            get
            {
                if (this._TermsandconditiongroupRepository == null)
                    this._TermsandconditiongroupRepository = new GenericRepository<TermsConditionGroup>(_context);
                return _TermsandconditiongroupRepository;
            }
        }
        public GenericRepository<ItemType> ItemTypeRepository
        {
            get
            {
                if (this._ItemTypeRepository == null)
                    this._ItemTypeRepository = new GenericRepository<ItemType>(_context);
                return _ItemTypeRepository;
            }
        }
        public GenericRepository<CategoryAttributeDtls> ItemTypeDtlsRepository
        {
            get
            {
                if (this._ItemTypeDtlsRepository == null)
                    this._ItemTypeDtlsRepository = new GenericRepository<CategoryAttributeDtls>(_context);
                return _ItemTypeDtlsRepository;
            }
        }
        public GenericRepository<TermsCondition> TermsConditionRepository
        {
            get
            {
                if (this._TermsConditionRepository == null)
                    this._TermsConditionRepository = new GenericRepository<TermsCondition>(_context);
                return _TermsConditionRepository;
            }
        }

        public GenericRepository<Catalog> catelogDetailsRepository
        {
            get
            {
                if (this._catalogRepository == null)
                    this._catalogRepository = new GenericRepository<Catalog>(_context);
                return _catalogRepository;
            }
        }
        public GenericRepository<CatalogImage_Details> catelogImageRepository
        {
            get
            {
                if (this._catalogimgaeRepository == null)
                    this._catalogimgaeRepository = new GenericRepository<CatalogImage_Details>(_context);
                return _catalogimgaeRepository;
            }
        }
        public GenericRepository<EventDetails> EventDetailsRepository
        {
            get
            {
                if (this._EventDetailsRepository == null)
                    this._EventDetailsRepository = new GenericRepository<EventDetails>(_context);
                return _EventDetailsRepository;
            }
        }

        /// <summary>
        /// Get/Set Property for city repository.
        /// </summary>
        ///

        public GenericRepository<ContactInfo> ContactInfoRepository
        {
            get
            {
                if (this._contactInfoRepository == null)
                    this._contactInfoRepository = new GenericRepository<ContactInfo>(_context);
                return _contactInfoRepository;
            }
        }
        public GenericRepository<Cart> CartRepository
        {
            get
            {
                if (this._cartRepository == null)
                    this._cartRepository = new GenericRepository<Cart>(_context);
                return _cartRepository;
            }
        }
        public GenericRepository<CartDetails> CartDetailsRepository
        {
            get
            {
                if (this._cartDetailsRepository == null)
                    this._cartDetailsRepository = new GenericRepository<CartDetails>(_context);
                return _cartDetailsRepository;
            }
        }
        public GenericRepository<WishList> WishListRepository
        {
            get
            {
                if (this._wishListRepository == null)
                    this._wishListRepository = new GenericRepository<WishList>(_context);
                return _wishListRepository;
            }
        }


        public GenericRepository<UserFeedback> UserFeedbackRepository
        {
            get
            {
                if (this._UserFeedbackRepository == null)
                    this._UserFeedbackRepository = new GenericRepository<UserFeedback>(_context);
                return _UserFeedbackRepository;
            }
        }
        public GenericRepository<ContactUs> ContactUsRepository
        {
            get
            {
                if (this._ContactUsRepository == null)
                    this._ContactUsRepository = new GenericRepository<ContactUs>(_context);
                return _ContactUsRepository;
            }
        }
        public GenericRepository<ReasonForMail> ReasonForMailRepository
        {
            get
            {
                if (this._ReasonForMailRepository == null)
                    this._ReasonForMailRepository = new GenericRepository<ReasonForMail>(_context);
                return _ReasonForMailRepository;
            }
        }
        public GenericRepository<Auction> AuctionRepository
        {
            get
            {
                if (this._auctionRepository == null)
                    this._auctionRepository = new GenericRepository<Auction>(_context);
                return _auctionRepository;
            }
        }
        public GenericRepository<Auction_Item_Details> AuctionItemRepository
        {
            get
            {
                if (this._auctionItemRepository == null)
                    this._auctionItemRepository = new GenericRepository<Auction_Item_Details>(_context);
                return _auctionItemRepository;
            }
        }
        public GenericRepository<Auction_Item_Bid_History> AuctionItemBidRepository
        {
            get
            {
                if (this._auctionItemBidRepository == null)
                    this._auctionItemBidRepository = new GenericRepository<Auction_Item_Bid_History>(_context);
                return _auctionItemBidRepository;
            }
        }

        public GenericRepository<Commission> CommissionRepository
        {
            get
            {
                if (this._CommissionRepository == null)
                    this._CommissionRepository = new GenericRepository<Commission>(_context);
                return _CommissionRepository;
            }
        }

        public GenericRepository<Tax> TaxRepository
        {
            get
            {
                if (this._TaxRepository == null)
                    this._TaxRepository = new GenericRepository<Tax>(_context);
                return _TaxRepository;
            }
        }
        public GenericRepository<AboutUs> AboutUsRepository
        {
            get
            {
                if (this._AboutUsRepository == null)
                    this._AboutUsRepository = new GenericRepository<AboutUs>(_context);
                return _AboutUsRepository;
            }
        }
        public GenericRepository<WebProfile> WebProfileRepository
        {
            get
            {
                if (this._WebProfileRepository == null)
                    this._WebProfileRepository = new GenericRepository<WebProfile>(_context);
                return _WebProfileRepository;
            }
        }
        public GenericRepository<WebContent> WebContentRepository
        {
            get
            {
                if (this._WebContentRepository == null)
                    this._WebContentRepository = new GenericRepository<WebContent>(_context);
                return _WebContentRepository;
            }
        }
        public GenericRepository<CatalogType> CatalogTypeRepository
        {
            get
            {
                if (this._CatalogTypeRepository == null)
                    this._CatalogTypeRepository = new GenericRepository<CatalogType>(_context);
                return _CatalogTypeRepository;
            }
        }
        public GenericRepository<EventType> EventTypeRepository
        {
            get
            {
                if (this._EventTypeRepository == null)
                    this._EventTypeRepository = new GenericRepository<EventType>(_context);
                return _EventTypeRepository;
            }
        }
        public GenericRepository<VenueType> VenueTypeRepository
        {
            get
            {
                if (this._VenueTypeRepository == null)
                    this._VenueTypeRepository = new GenericRepository<VenueType>(_context);
                return _VenueTypeRepository;
            }
        }
        public GenericRepository<DisplaySection> DisplaySectionRepository
        {
            get
            {
                if (this._DisplaySectionRepository == null)
                    this._DisplaySectionRepository = new GenericRepository<DisplaySection>(_context);
                return _DisplaySectionRepository;
            }
        }
        public GenericRepository<DisplaySectionTable> DisplaySectionTableRepository
        {
            get
            {
                if (this._DisplaySectionTableRepository == null)
                    this._DisplaySectionTableRepository = new GenericRepository<DisplaySectionTable>(_context);
                return _DisplaySectionTableRepository;
            }
        }
        public GenericRepository<Fequency> FequencyRepository
        {
            get
            {
                if (this._FequencyRepository == null)
                    this._FequencyRepository = new GenericRepository<Fequency>(_context);
                return _FequencyRepository;
            }
        }
        //public GenericRepository<Support> SupportRepository
        //{
        //    get
        //    {
        //        if (this._SupportRepository == null)
        //            this._SupportRepository = new GenericRepository<Support>(_context);
        //        return _SupportRepository;
        //    }
        //}

        public GenericRepository<ShipmentDetails> ShipmentDetailsRepository
        {
            get
            {
                if (this._ShipmentDetailsRepository == null)
                    this._ShipmentDetailsRepository = new GenericRepository<ShipmentDetails>(_context);
                return _ShipmentDetailsRepository;
            }
        }
        #region Company Barnding
        public GenericRepository<Banner> BannerRepository
        {
            get
            {
                if (this._bannerRepository == null)
                    this._bannerRepository = new GenericRepository<Banner>(_context);
                return _bannerRepository;
            }
        }
        public GenericRepository<Informal> InformalRepository
        {
            get
            {
                if (this._InformalRepository == null)
                    this._InformalRepository = new GenericRepository<Informal>(_context);
                return _InformalRepository;
            }
        }
        #endregion
       
        #region User
        public GenericRepository<Master_Login_User> UserRepository
        {
            get
            {
                if (this._userRepository == null)
                    this._userRepository = new GenericRepository<Master_Login_User>(_context);
                return _userRepository;
            }
        }
        //private GenericRepository<UserRole> _userRoleRepository;
        public GenericRepository<UserRole> UserRoleRepository
        {
            get
            {
                if (this._userRoleRepository == null)
                    this._userRoleRepository = new GenericRepository<UserRole>(_context);
                return _userRoleRepository;
            }
        }
        public GenericRepository<Event> EventRepository
        {
            get
            {
                if (this._eventRepository == null)
                    this._eventRepository = new GenericRepository<Event>(_context);
                return _eventRepository;
            }
        }
        //private GenericRepository<Role> _roleRepository;
        public GenericRepository<Role> RoleRepository
        {
            get
            {
                if (this._roleRepository == null)
                    this._roleRepository = new GenericRepository<Role>(_context);
                return _roleRepository;
            }
        }
        //private GenericRepository<RolePrevileges> _rolePrevilegesRepository;
        public GenericRepository<RolePrevileges> RolePrevilegesRepository
        {
            get
            {
                if (this._rolePrevilegesRepository == null)
                    this._rolePrevilegesRepository = new GenericRepository<RolePrevileges>(_context);
                return _rolePrevilegesRepository;
            }
        }
        //private GenericRepository<Feature> _featureRepository;
        public GenericRepository<Feature> FeatureRepository
        {
            get
            {
                if (this._featureRepository == null)
                    this._featureRepository = new GenericRepository<Feature>(_context);
                return _featureRepository;
            }
        }

        #endregion

        #region Menu & SubMenu &Feature
        public GenericRepository<Menu> MenuRepository
        {
            get
            {
                if (this._menuRepository == null)
                    this._menuRepository = new GenericRepository<Menu>(_context);
                return _menuRepository;
            }
        }
        public GenericRepository<SubMenu> SubMenuRepository
        {
            get
            {
                if (this._subMenuRepository == null)
                    this._subMenuRepository = new GenericRepository<SubMenu>(_context);
                return _subMenuRepository;
            }
        }
       
        #endregion

        #region Address
        public GenericRepository<User_Personal_Information> UserPersonalInformationRepository
        {
            get
            {
                if (this._UserPersonalInformationRepository == null)
                    this._UserPersonalInformationRepository = new GenericRepository<User_Personal_Information>(_context);
                return _UserPersonalInformationRepository;
            }
        }
        public GenericRepository<User_Banking_Information> User_Banking_InformationRepository
        {
            get
            {
                if (this._UserBankingInformationRepository == null)
                    this._UserBankingInformationRepository = new GenericRepository<User_Banking_Information>(_context);
                return _UserBankingInformationRepository;
            }
        }
        public GenericRepository<User_Additional_Information> User_Additional_InformationRepository
        {
            get
            {
                if (this._UserAdditionalInformationRepository == null)
                    this._UserAdditionalInformationRepository = new GenericRepository<User_Additional_Information>(_context);
                return _UserAdditionalInformationRepository;
            }
        }
        public GenericRepository<User_Address> User_AddressRepository
        {
            get
            {
                if (this._UserAddressRepository == null)
                    this._UserAddressRepository = new GenericRepository<User_Address>(_context);
                return _UserAddressRepository;
            }
        }
        #endregion

        #region Faq
        public GenericRepository<FAQ> FAQRepository
        {
            get
            {
                if (this._FAQRepository == null)
                    this._FAQRepository = new GenericRepository<FAQ>(_context);
                return _FAQRepository;
            }
        }
        public GenericRepository<FaqGroup> FaqGroupRepository
        {
            get
            {
                if (this._FaqGroupRepository == null)
                    this._FaqGroupRepository = new GenericRepository<FaqGroup>(_context);
                return _FaqGroupRepository;
            }
        }
        public GenericRepository<FaqStatus> FaqStatusRepository
        {
            get
            {
                if (this._FaqStatusRepository == null)
                    this._FaqStatusRepository = new GenericRepository<FaqStatus>(_context);
                return _FaqStatusRepository;
            }
        }
        #endregion

        public GenericRepository<Category> CataegoryRepository
        {
            get
            {
                if (this._categoryRepository == null)
                    this._categoryRepository = new GenericRepository<Category>(_context);
                return _categoryRepository;
            }
        }
        public GenericRepository<Relevent_Images> Relevent_ImagesRepository
        {
            get
            {
                if (this._Relevent_ImagesRepository == null)
                    this._Relevent_ImagesRepository = new GenericRepository<Relevent_Images>(_context);
                return _Relevent_ImagesRepository;
            }
        }
        public GenericRepository<Items> ItemsRepository
        {
            get
            {
                if (this._itemsRepository == null)
                    this._itemsRepository = new GenericRepository<Items>(_context);
                return _itemsRepository;
            }
        }
        public GenericRepository<Options> OptionsRepository
        {
            get
            {
                if (this._optionsRepository == null)
                    this._optionsRepository = new GenericRepository<Options>(_context);
                return _optionsRepository;
            }
        }
        public GenericRepository<Control> ControlRepository
        {
            get
            {
                if (this._controlRepository == null)
                    this._controlRepository = new GenericRepository<Control>(_context);
                return _controlRepository;
            }
        }
        public GenericRepository<ItemDetail> ItemDetailRepository
        {
            get
            {
                if (this._itemDetailRepository == null)
                    this._itemDetailRepository = new GenericRepository<ItemDetail>(_context);
                return _itemDetailRepository;
            }
        }
        public GenericRepository<BaseAttribute> BaseAttributeRepository
        {
            get
            {
                if (this._baseAttributeRepository == null)
                    this._baseAttributeRepository = new GenericRepository<BaseAttribute>(_context);
                return _baseAttributeRepository;
            }
        }
        public GenericRepository<Scheme> SchemeRepository
        {
            get
            {
                if (this._schemeRepository == null)
                    this._schemeRepository = new GenericRepository<Scheme>(_context);
                return _schemeRepository;
            }
        }
        public GenericRepository<SchemeTermsAndCondition> SchemeTermsAndConditionRepository
        {
            get
            {
                if (this._schemeTermsAndConditionRepository == null)
                    this._schemeTermsAndConditionRepository = new GenericRepository<SchemeTermsAndCondition>(_context);
                return _schemeTermsAndConditionRepository;
            }
        }
        public GenericRepository<SchemeType> SchemeTypeRepository
        {
            get
            {
                if (this._schemetypeRepository == null)
                    this._schemetypeRepository = new GenericRepository<SchemeType>(_context);
                return _schemetypeRepository;
            }
        }
        public GenericRepository<TopSection> TopSectionRepository
        {
            get
            {
                if (this._TopSectionRepository == null)
                    this._TopSectionRepository = new GenericRepository<TopSection>(_context);
                return _TopSectionRepository;
            }
        }
        public GenericRepository<MiddleSection> MiddleSectionRepository
        {
            get
            {
                if (this._MiddleSectionRepository == null)
                    this._MiddleSectionRepository = new GenericRepository<MiddleSection>(_context);
                return _MiddleSectionRepository;
            }
        }
        public GenericRepository<MiddleSectionAllow> MiddleSectionAllowRepository
        {
            get
            {
                if (this._MiddleSectionAllowRepository == null)
                    this._MiddleSectionAllowRepository = new GenericRepository<MiddleSectionAllow>(_context);
                return _MiddleSectionAllowRepository;
            }
        }
        public GenericRepository<City> CityRepository
        {
            get
            {
                if (this._cityRepository == null)
                    this._cityRepository = new GenericRepository<City>(_context);
                return _cityRepository;
            }
        }
        public GenericRepository<Country> CountryRepository
        {
            get
            {
                if (this._countryRepository == null)
                    this._countryRepository = new GenericRepository<Country>(_context);
                return _countryRepository;
            }
        }
        public GenericRepository<State> StateRepository
        {
            get
            {
                if (this._stateRepository == null)
                    this._stateRepository = new GenericRepository<State>(_context);
                return _stateRepository;
            }
        }

        public GenericRepository<ItemAttributeDetails> ItemAttributeDetailsRepository
        {
            get
            {
                if (this._ItemAttributeDetailsRepository == null)
                    this._ItemAttributeDetailsRepository = new GenericRepository<ItemAttributeDetails>(_context);
                return _ItemAttributeDetailsRepository;
            }
        }

        public GenericRepository<Support> SupportRepository
        {
            get
            {
                if (this._SupportRepository == null)
                    this._SupportRepository = new GenericRepository<Support>(_context);
                return _SupportRepository;
            }
        }
        public GenericRepository<OrderPlaced> OrderPlacedRepository
        {
            get
            {
                if (this._OrderPlacedRepository == null)
                    this._OrderPlacedRepository = new GenericRepository<OrderPlaced>(_context);
                return _OrderPlacedRepository;
            }
        }


        /// <summary>
        /// Get/Set Property for token repository.
        /// </summary>
        //public GenericRepository<Token> TokenRepository
        //{
        //    get
        //    {
        //        if (this._tokenRepository == null)
        //            this._tokenRepository = new GenericRepository<Token>(_context);
        //        return _tokenRepository;
        //    }
        //}
        #endregion

        #region Public member methods...
        /// <summary>
        /// Save method.
        /// </summary>
        public void Save()
        {
            try
            {
                _context.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {

                var outputLines = new List<string>();
                foreach (var eve in e.EntityValidationErrors)
                {
                    outputLines.Add(string.Format("{0}: Entity of type \"{1}\" in state \"{2}\" has the following validation errors:", DateTime.Now, eve.Entry.Entity.GetType().Name, eve.Entry.State));
                    foreach (var ve in eve.ValidationErrors)
                    {
                        outputLines.Add(string.Format("- Property: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage));
                    }
                }
                //System.IO.File.AppendAllLines(@"C:\errors.txt", outputLines);

                throw e;
            }

        }

        #endregion

        #region Implementing IDiosposable...

        #region private dispose variable declaration...
        private bool disposed = false;
        #endregion

        /// <summary>
        /// Protected Virtual Dispose method
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    Debug.WriteLine("UnitOfWork is being disposed");
                    _context.Dispose();
                }
            }
            this.disposed = true;
        }

        /// <summary>
        /// Dispose method
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }
}