/// <summary>
        ///     The event handler of this entity container which occurs on each
        ///     Request sent to the serivce. 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void ZGWSAMPLE_SRV_SendingRequest(object sender, System.Data.Services.Client.SendingRequestEventArgs e)
        {   
            HttpWebRequest webRequest = e.Request as HttpWebRequest;

            //ADN Modif
            ServiceDetails serviceDetail = null; // ConfigurationReaderHandler.Instance.GetServiceDetails("ZGWSAMPLE_SRV");
            
            if (serviceDetail == null)
            {
                serviceDetail = new ServiceDetails { Url = @"https://sapes1.sapdevcenter.com:443/sap/opu/odata/sap/ZGWSAMPLE_SRV/", Client = "", SSO = "BASIC" };
            }
			string language = System.Globalization.CultureInfo.CurrentUICulture.Name;
            webRequest.Headers["Accept-Language"] = language;
            BusinessConnectivityHelper.HandleSAPConnectivity(serviceDetail,ref webRequest);

			//The Below section helps you handle delta token. If you wish to use the details then pass the AtomDeltaToken back to your application.
            //To enable this section please set the value of "EnableDeltaToken" for the corresponding service to "Enabled".
            if (serviceDetail.HandleDeltaTokenDecision)
				{
					DataService dataService = new DataService();
					if (webRequest.Method == "GET")
						{
							HttpWebRequest clonedWebRequest = webRequest.CloneRequestForXSRFToken(webRequest.RequestUri.AbsoluteUri);
							HttpWebResponse webResponse = clonedWebRequest.GetResponse() as HttpWebResponse;
							if (webResponse.StatusCode == HttpStatusCode.OK)
								{
									string response = webResponse.ReadResponse();
									this.AtomDeltaToken = dataService.ReadResponse<AtomDeltaTokens>(response);
								}
						}
				}
			}

		public void Test1()
		{
			var ds = new DataService<NorthwindDB>();
			var mp = ds.GetService(typeof(IDataServiceMetadataProvider));


		}

        public void AddRemoveCategory()
        {
            var context = new CoreDataContext();
            var uow = new EntityFrameworkUnitOfWork(context);
            var repo = new EntityFrameworkRepository<Guid, Category, GuidIdInitializer>(context);

            var caregoryService = new DataService<Guid, Category, EntityFrameworkRepository<Guid, Category, GuidIdInitializer>>(uow, repo);

            var newCategory = caregoryService.Add(new Category
            {
                Name = "Computres",
                Categories = new List<Category>
                {
                    new Category { Name = "-DeskTops" },
                    new Category { Name = "-Servers" },
                    new Category { Name = "-Laptops", Categories = new List<Category>
                        {
                            new Category { Name = "--Tablets" },
                            new Category { Name = "--Shmablets" },
                        }
                    },
                }
            });

            var justAdded = caregoryService.Get(c => c.Id == newCategory.Id);
            Assert.AreEqual(justAdded.Categories.Count, newCategory.Categories.Count);

            caregoryService.Remove(justAdded);
            justAdded = caregoryService.Get(c => c.Id == newCategory.Id);
            Assert.IsNull(justAdded);
        }

 public MapViewModel(INavigationResolver resolver, DataService.IGeoDataService service) 
 {
     _resolver = resolver;
     _service = service;
     Issues = new ObservableCollection<DataService.IssueItem>();
     InitData();
 }

        public when_a_customer_is_requested()
        {
            fakeDataService = A.Fake<DataService>();
            //A.CallTo(() => fakeDataService.AddMessage()).MustHaveHappened();

            handler = new GetIndex(fakeDataService);
        }

 /// <summary>
 /// Fire up the repos and service context in the constructor.
 /// </summary>
 /// <param name="oAuthorization"></param>
 public SyncService(OAuthorizationdto oAuthorization)
 {
     dataserviceFactory = new DataserviceFactory(oAuthorization);
     dataService = dataserviceFactory.getDataService();
     syncObjects = new Syncdto();
     syncRepository = new SyncRepository();
 }

 public void TestDeleteValue()
 {
     DataService dataService = new DataService();
     dataService.SetValue("TestKey", "TestValue");
     dataService.DeleteValue("TestKey");
     Assert.IsInstanceOf(typeof(KeyNotFoundException), dataService.GetValue("TestKey").ThrownException);
 }

 void client_GetGestureDataCompleted(object sender, DataService.GetGestureDataCompletedEventArgs e)
 {
     if (e.Error == null)
     {
         gestureInfo = SerializationHelper.Desirialize(e.Result);
         defBuilder.AddGesture(gestureInfo);
     }
 }

 private void Load_Data()
 {
     DataService dataservice = new DataService();
     dataSet = dataservice.GetSubjectAndWords();
     Page.Session["DataSet"] = dataSet;
     
    
 }

	//Metodo para obtener las  Respuestas desde la base de datos.
	public void getAnswers(){
		ds = new DataService("medicina.db");	/*Especifia nombre de la base de datos*/
		ds.CreateDB ();
		var respuestas=ds.GetRespuestas(); /*El numero 1 es el ID de la pregunta que estamos evaluando*/
		foreach(var respuesta in respuestas){
			answer = respuesta.Texto;
		}
	}

 public SqliteEntityLiteProvider(DataService dataService)
     : base(dataService)
 {
     if (DataService.ProviderName != ProviderName)
     {
         throw new InvalidOperationException(this.GetType().Name + " is for " + ProviderName + ". Not for " + DataService.ProviderName);
     }
 }

 public DataTable LayDsQuyDinh()
 {
     SqlCommand cmd = new SqlCommand("SELECT * FROM QUYDINH");
     DataService dS = new DataService();
     dS.Load(cmd);
     m_QuyDinhData = dS;
     return m_QuyDinhData;
 }

 public int XoaPhieuThu(int SoPT)
 {
     SqlCommand cmd = new SqlCommand("dbo.Delete_PhieuThu");
     cmd.CommandType = CommandType.StoredProcedure;
     cmd.Parameters.Add(new SqlParameter("@SoPT", SoPT));
     DataService dS = new DataService();
     return dS.ExecuteNoneQuery(cmd);
 }

        static void Main(string[] args)
        {
            DataService dataService = new DataService(new IntData());
            dataService.SendAndReceive();

            dataService.SetData(new StringData());
            dataService.SendAndReceive();
        }

 public DataTable LayDsNhanVien()
 {
     SqlCommand cmd = new SqlCommand(TruyVanChung());
     DataService dS = new DataService();
     dS.Load(cmd);
     m_NhanVienData = dS;
     return m_NhanVienData;
 }

 public int XacNhanPhieuChi(int SoPC)
 {
     SqlCommand cmd = new SqlCommand("dbo.XacNhan_PhieuChi");
     cmd.CommandType = CommandType.StoredProcedure;
     cmd.Parameters.Add(new SqlParameter("@SoPC", SoPC));
     DataService dS = new DataService();
     return dS.ExecuteNoneQuery(cmd);
 }

 public DataTable LayDsKhoanChi(String sqlString)
 {
     SqlCommand cmd = new SqlCommand(sqlString);
     DataService dS = new DataService();
     dS.Load(cmd);
     m_KhoanChiData = dS;
     return m_KhoanChiData;
 }

        public static int CapNhatTaiKhoanCo(Int64 taiKhoanCo)
        {
            DataService m_QuyDinhData = new DataService();
            SqlCommand cmd = new SqlCommand("UPDATE QUYDINH SET TaiKhoanCo = TaiKhoanCo + @taiKhoanCo");
            cmd.Parameters.Add("taiKhoanCo", SqlDbType.BigInt).Value = taiKhoanCo;

            return m_QuyDinhData.Load(cmd);
        }

        public static int CapNhatTimKiemTuDong(Boolean timKiemTuDong)
        {
            DataService m_QuyDinhData = new DataService();
            SqlCommand cmd = new SqlCommand("UPDATE QUYDINH SET TimKiemTuDong= @timKiemTuDong");
            cmd.Parameters.Add("timKiemTuDong", SqlDbType.Bit).Value = timKiemTuDong;

            return m_QuyDinhData.Load(cmd);
        }

 public void ApiOnline()
 {
     Task.Run(async () =>
     {
         var ds = new DataService();
         Assert.IsTrue(await ds.ApiOnline());
     });
 }