public IEnumerable <ZipCodeData> GetZips(string zip, int range)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _zipCodeRespository ?? new ZipCodeRepository();
ZipCode zipEntity = zipCodeRepository.GetByZip(zip);
IEnumerable <ZipCode> zips = zipCodeRepository.GetZipsForRange(zipEntity, range);
if (zips != null)
{
foreach (var zipCode in zips)
{
zipCodeData.Add(new ZipCodeData()
{
ZipCode = zipCode.Zip,
City = zipCode.City,
State = zipCode.State.Abbreviation
});
}
}
return(zipCodeData);
}
public IEnumerable <ZipCodeData> GetZips(string zip, int range)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipEntity = zipCodeRepository.GetByZip(zip);
IEnumerable <ZipCode> zips = zipCodeRepository.GetZipsForRange(zipEntity, range);
if (zips != null)
{
foreach (ZipCode zipCode in zips)
{
zipCodeData.Add(new ZipCodeData()
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
});
}
}
Console.WriteLine("GetZips(zip, range) called here.");
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
ApplicationException ex = new ApplicationException(string.Format("Zip code {0} not found.", zip));
throw new FaultException <ApplicationException>(ex, "Just another message");
}
return(zipCodeData);
}
public void UpdateZipCty(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository rep = _repZip ?? new ZipCodeRepository();
//This below would be the efficient way to do
//var cityBatch = zipCityData.ToDictionary(c => c.ZipCode, c => c.City);
//rep.UpdateZipBatch(cityBatch);
//For simulate error in a transaction we gonna use this ugly code below
int counter = 0;
foreach (var cityData in zipCityData)
{
// in a operation without transaction only the first one will succeed.
//counter++;
//if (counter==2) throw new FaultException("Sorry, no can do !");
ZipCode zip = rep.GetByZip(cityData.ZipCode);
zip.City = cityData.City;
ZipCode updatedZipCode = rep.Update(zip);
}
// To regain control of when and where the transaction is closed
// it needs to set the TransactionAutoCompleteto false, because the default is true
// This code below closes the transaction
OperationContext.Current.SetTransactionComplete();
}
public void UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
//Dictionary<string,string> cityBatch = new Dictionary<string, string>();
//foreach (ZipCityData zipCityItem in zipCityData)
//{
// cityBatch.Add(zipCityItem.ZipCode,zipCityItem.City);
//}
//zipCodeRepository.UpdateCityBatch(cityBatch);
int counter = 0;
foreach (var zipCityItem in zipCityData)
{
counter++;
ZipCode zipEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
if (zipEntity != null)
{
zipEntity.City = zipCityItem.City;
zipCodeRepository.Update(zipEntity);
ZipCode updateItem = zipCodeRepository.Update(zipEntity);
}
}
}
public void UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository repository = _ZipCodeRepository ?? new ZipCodeRepository();
//Dictionary<string, string> cityBatch = new Dictionary<string, string>();
//foreach (var zipCity in zipCityData)
//{
// cityBatch.Add(zipCity.ZipCode, zipCity.City);
//}
//repository.UpdateBatch(cityBatch);
int counter = 0;
foreach (var zipCityItem in zipCityData)
{
counter++;
if (counter == 2)
{
throw new FaultException("Sorry you cannot do that.");
}
ZipCode zipEntity = repository.GetByZip(zipCityItem.ZipCode);
if (zipEntity != null)
{
zipEntity.City = zipCityItem.City;
repository.Update(zipEntity);
}
}
OperationContext.Current.SetTransactionComplete();
}
public ZipCodeData GetZipInfo(string zip)
{
//Test after set timeout to 5 seconds. It throws a timeout exception.
//Thread.Sleep(10000);
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
//Used as Unhandled Exception. Sets the proxy state at the client to "Faulted"
//throw new ApplicationException(string.Format("Zip code {0} not found.", zip));
//Used as Handled Exception. Keeps the proxy state at the client to "Opened"
//throw new FaultException(string.Format("Zip code {0} not found.", zip));
//Used with FaultContract that must be declared at the contract level, the IGeoService in this case. Keeps the proxy state at the client to "Opened"
//ApplicationException ex = new ApplicationException(string.Format("Zip code {0} not found.", zip));
//throw new FaultException<ApplicationException>(ex, "Just another message");
//Better and most powerful way to throw an exception. Using FaultContract that must be declared at the contract level,
//and using a custom Class to define and send the information needed. Keeps the proxy state at the client to "Opened"
NotFoundData data = new NotFoundData()
{
Message = string.Format("Zip code {0} not found.", zip),
When = DateTime.Now.ToString(),
User = "******" //It can be recovered by Identity or anythin else.
};
throw new FaultException <NotFoundData>(data, "Just another message.");
}
//lock (this)
//{
// _Counter++;
//}
//MyStaticResource.DoSomething();
//Keep this only if the Host is a Console.
//Console.WriteLine("Count = {0}", _Counter.ToString());
//Used in Instancing and Concurrency for demonstration. Need reference to PresentationFramework and using System.Window;
//MessageBox.Show(string.Format("{0} = {1}, {2}", zip, zipCodeData.City, zipCodeData.State), "Call Counter " + _Counter.ToString());
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
var zipCode = _zipCodeRepo.GetByZip(zip);
if (zipCode != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
};
}
return(zipCodeData);
}
public void UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
int counter = 0;
foreach (ZipCityData zipCityItem in zipCityData)
{
counter++;
//if (counter == 2)
//{
// throw new FaultException("sorry, no can do.");
//}
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
zipCodeEntity.City = zipCityItem.City;
ZipCode updateItem = zipCodeRepository.Update(zipCodeEntity);
}
//using (TransactionScope scope = new TransactionScope())
//{
// int counter = 0;
// foreach (ZipCityData zipCityItem in zipCityData)
// {
// counter++;
// if (counter == 2)
// {
// throw new FaultException("sorry, no can do.");
// }
// ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
// zipCodeEntity.City = zipCityItem.City;
// ZipCode updateItem = zipCodeRepository.Update(zipCodeEntity);
// }
// scope.Complete();
//}
//OperationContext.Current.SetTransactionComplete();
//IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
//Dictionary<string, string> cityBatch = new Dictionary<string, string>();
//foreach (ZipCityData zipCityItem in zipCityData)
//{
// cityBatch.Add(zipCityItem.ZipCode, zipCityItem.City);
//}
//zipCodeRepository.UpdateCityBatch(cityBatch);
}
public void UpdateZipCity(string zip, string city)
{
IZipCodeRepository repository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipEntity = repository.GetByZip(zip);
if (zipEntity != null)
{
zipEntity.City = city;
repository.Update(zipEntity);
}
}
public void UpdateZipCity(string zip, string city)
{
IZipCodeRepository rep = _repZip ?? new ZipCodeRepository();
ZipCode zipCode = rep.GetByZip(zip);
if (zipCode == null)
{
return;
}
zipCode.City = city;
rep.Update(zipCode);
}
public IEnumerable <ZipCodeData> GetZip(string zip, int range)
{
IZipCodeRepository rep = _repZip ?? new ZipCodeRepository();
ZipCode zipCode = rep.GetByZip(zip);
IEnumerable <ZipCode> zipCodes = rep.GetZipsForRange(zipCode, range);
IEnumerable <ZipCodeData> result = zipCodes.Select(s => new ZipCodeData
{
State = s.State.Abbreviation,
ZipCode = s.Zip,
City = s.City
}).ToList();
return(result);
}
//[OperationBehavior(TransactionScopeRequired = true, TransactionAutoComplete = false)]
//[OperationBehavior(TransactionScopeRequired = false)]
public void UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
#region efficient way of handling batch update
//Dictionary<string, string> cityBatch = new Dictionary<string, string>();
//
//foreach (ZipCityData zipCityItem in zipCityData)
// cityBatch.Add(zipCityItem.ZipCode, zipCityItem.City);
//
//zipCodeRepository.UpdateCityBatch(cityBatch);
#endregion
#region more inefficient, but allows for failing part of it
int counter = 0;
foreach (ZipCityData zipCityItem in zipCityData)
{
counter++;
//if (counter == 2)
// throw new FaultException("Sorry, no can do.");
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
zipCodeEntity.City = zipCityItem.City;
ZipCode updatedItem = zipCodeRepository.Update(zipCodeEntity);
}
//OperationContext.Current.SetTransactionComplete();
#endregion
#region manual transaction handling
//using (TransactionScope scope = new TransactionScope())
//{
// int counter = 0;
// foreach (ZipCityData zipCityItem in zipCityData)
// {
// counter++;
// if (counter == 2)
// throw new FaultException("Sorry, no can do.");
// ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
// zipCodeEntity.City = zipCityItem.City;
// ZipCode updatedItem = zipCodeRepository.Update(zipCodeEntity);
// }
// scope.Complete();
//}
#endregion
}
public ZipCodeData GetZipInfo(string zip)
{
// verifying if is coming from unit test or real call
IZipCodeRepository rep = _repZip ?? new ZipCodeRepository();
// Doing the encapsulated thing that it should
ZipCode zipCode = rep.GetByZip(zip);
if (zipCode == null)
{
Exception ex = new InvalidOperationException("Zip code not found");
//Every exception thrown by the service will be a FaultException
//but this will be considered as unhandled one and will receive a generic message
//throw ex;
//Even with IncludeExceptionDetailInFaults false is possible to send a fail message
//this is the simplest form of handled FaultException just explaining the reason.
//throw new FaultException(new FaultReason("Zip code not found"));
//Is possible also to send the actual exception details like:
//message, inner exception, stack trace, etc.
//just put the ex exception in a new exception detail.
throw new FaultException <ExceptionDetail>(new ExceptionDetail(ex), "No records");
// Custom error object.
//NotFoundData data = new NotFoundData
//{
// Message = "Zip code not found",
// When = DateTime.Now.ToString(),
// User = "******"
//};
//It is possible even send a kind of exception like InvalidOperationException
// or in this case a custom error object
//throw new FaultException<NotFoundData>(data, "No records");
}
ZipCodeData result = new ZipCodeData
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
};
// returning what the client is expecting
return(result);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
string hostIdentity = WindowsIdentity.GetCurrent().Name;
//string primaryIdentity = ServiceSecurityContext.Current.PrimaryIdentity.Name;
//string windowsIdentity = ServiceSecurityContext.Current.WindowsIdentity.Name;
//string threadIdentity = Thread.CurrentPrincipal.Identity.Name;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
//throw new ApplicationException($"Zip code {zip} not found.");
//throw new FaultException($"Zip code {zip} not found.");
//ApplicationException ex = new ApplicationException($"Zip code {zip} not found.");
//throw new FaultException<ApplicationException>(ex, "Just another message");
NotFoundData data = new NotFoundData()
{
Message = $"Zip code {zip} not found.",
When = DateTime.Now.ToString(),
User = "******"
};
throw new FaultException <NotFoundData>(data, "Just another message");
}
_Counter++;
//Console.WriteLine($"Counter = {_Counter.ToString()}");
//Thread.Sleep(10000);
//MessageBox.Show($"{zip} = {zipCodeData.City}, {zipCodeData.State}", "Call Counter " + _Counter);
return(zipCodeData);
}
public IEnumerable <ZipCodeData> GetZips(string zip, int range)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
var zipEntity = zipCodeRepository.GetByZip(zip);
var zips = zipCodeRepository.GetZipsForRange(zipEntity, range);
if (zips != null)
{
zipCodeData.AddRange(zips.Select(zipCode => new ZipCodeData
{
City = zipCode.City, State = zipCode.State.Abbreviation, ZipCode = zipCode.Zip
}));
}
return(zipCodeData);
}
public ZipCodeData GetZipcodeInfo(string zip)
{
Thread.Sleep(10);
ZipCodeData data = null;
IZipCodeRepository repo = _zipCodeRepository ?? new ZipCodeRepository();
var zipCodeEntity = repo.GetByZip(zip);
if (zipCodeEntity != null)
{
data = new ZipCodeData
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
return(data);
}
public void UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
foreach (ZipCityData zipCityItem in zipCityData)
{
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
zipCodeEntity.City = zipCityItem.City;
ZipCode updatedItem = zipCodeRepository.Update(zipCodeEntity);
IUpdateZipCallback callback =
OperationContext.Current.GetCallbackChannel <IUpdateZipCallback>();
if (callback != null)
{
callback.ZipUpdated(zipCityItem);
}
}
}
public IEnumerable <ZipCodeData> GetZips(string zip, int range)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipEntity = zipCodeRepository.GetByZip(zip);
var zips = zipCodeRepository.GetZipsForRange(zipEntity, range);
if (zips != null)
{
foreach (ZipCode zipCode in zips)
{
zipCodeData.Add(LocalConfiguration.Mapper.Map <ZipCodeData>(zipCode));
}
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
//throw new DivideByZeroException("you cannot try this");
ZipCodeData zipCodeData = null;
string hostIdentity = WindowsIdentity.GetCurrent().Name;
string primaryIdentity = ServiceSecurityContext.Current.PrimaryIdentity.Name;
string windowsIdentity = ServiceSecurityContext.Current.WindowsIdentity.Name;
string threadIdentity = Thread.CurrentPrincipal.Identity.Name;
IZipCodeRepository zipCodeRepository = _zipCodeRespository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
ZipCode = zipCodeEntity.Zip,
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation
};
}
else
{
//throw new ApplicationException($"Zip code {zip} not found.");
//throw new FaultException($"Zip code {zip} not found.");
//ApplicationException ex = new ApplicationException($"Zip code {zip} not found.");
//throw new FaultException<ApplicationException>(ex, "Just another message");
NotFoundData data = new NotFoundData()
{
Message = string.Format($"Zip code {zip} not found."),
When = DateTime.Now.ToString(CultureInfo.InvariantCulture),
User = "******"
};
throw new FaultException <NotFoundData>(data, "No reason");
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
//Thread.Sleep(10000);
_Counter++;
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = LocalConfiguration.Mapper.Map <ZipCodeData>(zipCodeEntity);
}
Console.WriteLine("Counter = {0}", _Counter);
return(zipCodeData);
}
public void TestZipCodeRetrieval()
{
IZipCodeRepository repository = Substitute.For <IZipCodeRepository>();
ZipCode zipCode = new ZipCode()
{
City = "LINCOLN PARK",
State = new State()
{
Abbreviation = "NJ"
},
Zip = "07035"
};
repository.GetByZip("07035").Returns(zipCode);
IGeoService geoManager = new GeoManager(repository);
var data = geoManager.GetZipInfo(zipCode.Zip);
Assert.Equal(zipCode.City, data.City);
Assert.Equal(zipCode.State.Abbreviation, data.State);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
//throw new FaultException(string.Format("Zip code {0} not found.", zip));
//throw new ApplicationException(string.Format("Zip code {0} not found.", zip));
//ApplicationException ex = new ApplicationException(string.Format("Zip code {0} not found.", zip));
//throw new FaultException<ApplicationException>(ex, "Reason for failure.");
NotFoundData data = new NotFoundData()
{
Message = string.Format("Zip code {0} not found.", zip),
When = DateTime.Now.ToString(),
User = "******"
};
throw new FaultException <NotFoundData>(data, "Just another message.");
}
_Counter++;
return(zipCodeData);
}
//[PrincipalPermission(SecurityAction.Demand, Role = "Администраторы")]
public int UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
string hostIdentity = WindowsIdentity.GetCurrent().Name;
string primaryIdentity = ServiceSecurityContext.Current.PrimaryIdentity.Name;
string windowsIdentity = ServiceSecurityContext.Current.WindowsIdentity.Name;
string threadIdentity = Thread.CurrentPrincipal.Identity.Name;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
//Dictionary<string, string> cityBatch = new Dictionary<string, string>();
//foreach (ZipCityData zipCityItem in zipCityData)
//{
// cityBatch.Add(zipCityItem.ZipCode, zipCityItem.City);
//}
//zipCodeRepository.UpdateCityBatch(cityBatch);
int counter = 0;
foreach (var zipCityItem in zipCityData)
{
counter++;
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
zipCodeEntity.City = zipCityItem.City;
ZipCode updateItem = zipCodeRepository.Update(zipCodeEntity);
//if (counter == 3)
// throw new FaultException("Manually caused error.");
IUpdateZipCallback callback = OperationContext.Current.GetCallbackChannel <IUpdateZipCallback>();
if (callback != null)
{
callback.ZipUpdated(zipCityItem);
Thread.Sleep(100);
}
}
return(counter);
}
public int UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
int counter = 0;
foreach (ZipCityData zipCityItem in zipCityData)
{
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.ZipCode);
zipCodeEntity.City = zipCityItem.City;
ZipCode updatedItem = zipCodeRepository.Update(zipCodeEntity);
IUpdateZipCallback callback = OperationContext.Current.GetCallbackChannel <IUpdateZipCallback>();
if (callback != null)
{
callback.ZipUpdated(zipCityItem);
Thread.Sleep(500);
}
counter++;
}
return(counter);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
throw new FaultException(string.Format("Zip code {0} not found.", zip));
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
ServiceSecurityContext context = ServiceSecurityContext.Current;
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
Console.WriteLine("GetZipInfo() called here.");
return(zipCodeData);
}
//[OperationBehavior(TransactionScopeRequired = false)]
public void UpdateZipCity(IEnumerable <ZipCityData> zipCityData)
{
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
#region Good code. Try to do this way always.
//Dictionary<string, string> cityBatch = new Dictionary<string, string>();
//foreach (ZipCityData zipCityItem in zipCityData)
//{
// cityBatch.Add(zipCityItem.Zip, zipCityItem.City);
//}
//zipCodeRepository.UpdateCityBatch(cityBatch);
#endregion
#region Throw Error
int counter = 0;
foreach (ZipCityData zipCityItem in zipCityData)
{
counter++;
//This comment is to test throwing the error at the client.
//if (counter == 2)
//{
// //If TransactionAutoComplete = false, the below throw can not be raised, instead, do not "void",
// //return something through the method.
// throw new FaultException("Sorry, can't touch this!");
//}
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.Zip);
zipCodeEntity.City = zipCityItem.City;
ZipCode updateItem = zipCodeRepository.Update(zipCodeEntity);
}
#endregion
#region Manual Transaction Programming
//Default is TransactionScopeOption.Required
//using (TransactionScope scope = new TransactionScope())
//{
// int counter = 0;
// foreach (ZipCityData zipCityItem in zipCityData)
// {
// counter++;
// if (counter == 2)
// {
// throw new FaultException("Sorry, can't touch this!");
// }
// ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zipCityItem.Zip);
// zipCodeEntity.City = zipCityItem.City;
// ZipCode updateItem = zipCodeRepository.Update(zipCodeEntity);
// }
// scope.Complete();
//}
#endregion
//To perform manual transaction commit, set TransactionAutoComplete = false, and proceed the line below:
//OperationContext.Current.SetTransactionComplete();
}
public ZipCode GetZipInfo(string zip)
{
ZipCode zipCodeEntity = _ZipCodeRepository.GetByZip(zip);
return(zipCodeEntity);
}