private static void CreateLensesIfNotExist(PhotographySystemEntities context, IEnumerable <XElement> xLenses, Manufacturer manufacturer)
{
foreach (var xLense in xLenses)
{
var lensModel = xLense.Attribute("model").Value;
var lensType = xLense.Attribute("type").Value;
var lensPrice = xLense.Attribute("price");
var lens = context.Lenses.FirstOrDefault(l => l.Model == lensModel);
if (lens != null)
{
Console.WriteLine("Existing lens: {0}", lensModel);
}
else
{
lens = new Lens
{
Model = lensModel,
Type = lensType,
Price = lensPrice != null?decimal.Parse(lensPrice.Value) : default(decimal?),
ManufacturerId = manufacturer.Id
};
context.Lenses.Add(lens);
context.SaveChanges();
Console.WriteLine("Created lens: {0}", lensModel);
}
}
}
static void Main(string[] args)
{
var directoryToSaveTo = new DirectoryInfo("../../../manufacturers-and-cameras.json");
var context = new PhotographySystemEntities();
var manufacturers = context.Manufacturers
.Select(m => new
{
manufacturer = m.Name,
cameras = m.Cameras
.Select(c => new
{
model = c.Model,
price = c.Price
})
.OrderBy(c => c.model)
})
.OrderBy(m => m.manufacturer)
.ToList();
var serializer = new JavaScriptSerializer();
var json = serializer.Serialize(manufacturers);
Console.WriteLine("Saved to {0}", directoryToSaveTo.FullName);
File.WriteAllText(directoryToSaveTo.FullName, json);
}
private static Manufacturer ProcessManufacturer(PhotographySystemEntities context, XElement manufacturer)
{
var manufacturerNameNode = manufacturer.Element("manufacturer-name");
if (manufacturerNameNode == null)
{
throw new ArgumentException("Manufacturer name is mandatory!");
}
var name = manufacturerNameNode.Value;
var processedManufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == name);
if (processedManufacturer == null)
{
processedManufacturer = new Manufacturer()
{
Name = name
};
context.Manufacturers.Add(processedManufacturer);
context.SaveChanges();
Console.WriteLine("Created manufacturer: {0}", processedManufacturer.Name);
}
else
{
Console.WriteLine("Existing manufacturer: {0}", processedManufacturer.Name);
}
return(processedManufacturer);
}
static void Main(string[] args)
{
var xml = XDocument.Load(ManufacturerPath);
var manufacturerNodes = xml.XPathSelectElements("manufacturers/manufacturer");
var context = new PhotographySystemEntities();
foreach (var manufacturerNode in manufacturerNodes)
{
var manufacturerEntity = new Manufacturer();
var manufacturerName = manufacturerNode.Attribute("name").Value;
if (context.Manufacturers.Any(m => m.Name == manufacturerName))
{
Console.WriteLine("Manufacturer {0} already exists.",
manufacturerName);
continue;
}
manufacturerEntity.Name = manufacturerName;
var cameras = manufacturerNode.XPathSelectElements("cameras/camera");
ImportCameras(cameras, manufacturerEntity);
var lenses = manufacturerNode.XPathSelectElements("lenses/lens");
ImportLenses(lenses, manufacturerEntity);
context.Manufacturers.Add(manufacturerEntity);
context.SaveChanges();
Console.WriteLine("Successfully added manufacturer {0}.", manufacturerName);
}
}
static void Main(string[] args)
{
var context = new PhotographySystemEntities();
ExportAlbumsAsJson(context);
ExportAlbumsAsXml(context);
}
private static Manufacturer CreateManufacturerIfNotExists(PhotographySystemEntities context, XElement xManufacturer)
{
Manufacturer manufacturer = null;
var xManifName = xManufacturer.Element("manufacturer-name");
if (xManifName != null)
{
var manifacName = xManifName.Value;
manufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == manifacName);
if (manufacturer != null)
{
Console.WriteLine("Existing manufacturer: {0}", manifacName);
}
else
{
manufacturer = new Manufacturer
{
Name = manifacName
};
context.Manufacturers.Add(manufacturer);
context.SaveChanges();
Console.WriteLine("Created manufacturer: {0}", manifacName);
}
}
return(manufacturer);
}
static void Main(string[] args)
{
var directoryToSaveTo = new DirectoryInfo("../../../photographs.xml");
var context = new PhotographySystemEntities();
var photographs = context.Photographs
.Select(p => new
{
p.Title,
CategoryName = p.Category.Name,
p.Link,
Equipment = new
{
Camera = new
{
p.Equipment.Camera.Megapixels,
Model = p.Equipment.Camera.Manufacturer.Name + " " + p.Equipment.Camera.Model
},
Lens = new
{
Model = p.Equipment.Lens.Manufacturer.Name + " " + p.Equipment.Lens.Model,
p.Equipment.Lens.Price
}
},
})
.OrderBy(p => p.Title)
.ToList();
var xml = new XDocument();
var root = new XElement("photographs");
xml.Add(root);
foreach (var photograph in photographs)
{
var photoNode = new XElement("photograph");
photoNode.SetAttributeValue("title", photograph.Title);
photoNode.Add(new XElement("category", photograph.CategoryName));
photoNode.Add(new XElement("link", photograph.Link));
var equipmentNode = new XElement("equipment");
var camera = new XElement("camera", photograph.Equipment.Camera.Model);
camera.SetAttributeValue("megapixels", photograph.Equipment.Camera.Megapixels);
equipmentNode.Add(camera);
var lens = new XElement("lens", photograph.Equipment.Lens.Model);
if (photograph.Equipment.Lens.Price != null)
{
lens.SetAttributeValue("price", photograph.Equipment.Lens.Price);
}
equipmentNode.Add(lens);
photoNode.Add(equipmentNode);
root.Add(photoNode);
}
Console.WriteLine("Saved to {0}", directoryToSaveTo.FullName);
xml.Save(directoryToSaveTo.FullName);
}
static void Main()
{
var context = new PhotographySystemEntities();
var photographs = context.Photographs
.OrderBy(x => x.Title)
.Select(x => new
{
PhotographTitle = x.Title,
PhotographLink = x.Link,
Category = x.Category.Name,
Equipment = new
{
Camera = new
{
Name = x.Equipment.Camera.Manufacturer.Name + " " + x.Equipment.Camera.Model,
Megapixels = x.Equipment.Camera.Megapixels
},
Lens = new
{
Name = x.Equipment.Lens.Manufacturer.Name + " " + x.Equipment.Lens.Model,
Price = x.Equipment.Lens.Price
}
},
}).ToList();
XElement photos = new XElement("photographs");
foreach (var photo in photographs)
{
var photograph = new XElement("photograph", new XAttribute("title", photo.PhotographTitle));
photograph.Add(new XElement("category", photo.Category));
photograph.Add(new XElement("link", photo.PhotographLink));
var equipment = new XElement("equipment");
equipment.Add(new XElement("camera", new XAttribute("megapixels", photo.Equipment.Camera.Megapixels), photo.Equipment.Camera.Name));
var lens = new XElement("lens", photo.Equipment.Lens.Name);
if (photo.Equipment.Lens.Price != null)
{
lens.Add(new XAttribute("price", photo.Equipment.Lens.Price));
}
equipment.Add(lens);
photograph.Add(equipment);
photos.Add(photograph);
}
//Console.WriteLine(photos);
photos.Save("../../photographs.xml");
}
static void Main(string[] args)
{
// Ensure date formatting will use the English names
Encoding asciiEncoding = Encoding.UTF8;
var context = new PhotographySystemEntities();
var photographs = context.Photographs
.Select(p => new
{
PhotographTitle = p.Title,
Category = p.Category.Name,
CameraLink = p.Link,
CameraPixelsAttribute = p.Equipment.Camera.Megapixels == null ? String.Empty : p.Equipment.Camera.Megapixels.Value.ToString(),
CameraManAndModel = p.Equipment.Camera.Manufacturer.Name + " " + p.Equipment.Camera.Model,
LensModel = p.Equipment.Lens.Manufacturer.Name + " " + p.Equipment.Lens.Model,
LensPriceAttribute = p.Equipment.Lens.Price
}).OrderBy(p => p.PhotographTitle).ToList();
var photographsXML = new XElement("photographs");
foreach (var photograph in photographs)
{
var photographXML = new XElement("photograph",
new XAttribute("title", photograph.PhotographTitle),
new XElement("category", photograph.Category),
new XElement("link", photograph.CameraLink)
);
var equipment = new XElement("equipment");
var cameraXML = new XElement("camera", photograph.CameraManAndModel);
if (photograph.CameraPixelsAttribute != null)
{
cameraXML.Add(new XAttribute("megapixels", photograph.CameraPixelsAttribute));
}
var lens = new XElement("lens", photograph.LensModel);
if (photograph.LensPriceAttribute != null)
{
lens.Add(new XAttribute("price", string.Format("{0:f2}", photograph.LensPriceAttribute)));
}
equipment.Add(cameraXML);
equipment.Add(lens);
photographXML.Add(equipment);
photographsXML.Add(photographXML);
}
Console.WriteLine(photographsXML);
photographsXML.Save("../../photographs.xml");
}
private static void ProcessLenses(PhotographySystemEntities context, XElement lense, Manufacturer manufacturer)
{
var modelNode = lense.Attribute("model");
if (modelNode == null)
{
throw new ArgumentException("Model is mandatory for lenses!");
}
var model = modelNode.Value;
var typeNode = lense.Attribute("type");
if (typeNode == null)
{
throw new ArgumentException("Type is required for lenses!");
}
var type = typeNode.Value;
decimal?price = null;
var priceNode = lense.Attribute("price");
if (priceNode != null)
{
price = decimal.Parse(priceNode.Value);
}
Lens processedLense = context.Lenses.FirstOrDefault(l => l.Model == model);
if (processedLense == null)
{
processedLense = new Lens()
{
Model = model,
Type = type,
Price = price,
Manufacturer = manufacturer
};
context.Lenses.AddOrUpdate(processedLense);
context.SaveChanges();
Console.WriteLine("Created lens: {0}", processedLense.Model);
}
else
{
Console.WriteLine("Existing lens: {0}", processedLense.Model);
}
}
private static void ExportAlbumsAsJson(PhotographySystemEntities context)
{
var albums = context.Albums
.Where(a => a.Photographs.Count >= 1)
.OrderBy(a => a.Photographs.Count)
.ThenBy(a => a.Id)
.Select(a => new
{
a.Id,
a.Name,
owner = a.User.FullName,
photoCount = a.Photographs.Count
});
var albumsAsJson = JsonConvert.SerializeObject(albums, Formatting.Indented);
File.WriteAllText("albums.json", albumsAsJson);
}
static void Main()
{
var context = new PhotographySystemEntities();
XDocument xmlDoc = XDocument.Load("../../manufacturers-and-lenses.xml");
var xManufacturers = xmlDoc.XPathSelectElements("/manufacturers-and-lenses/manufacturer");
int manufacturerNumber = 1;
foreach (var xManufacturer in xManufacturers)
{
Console.WriteLine("Processing manufacturer #{0} ...", manufacturerNumber++);
Manufacturer manufacturer = CreateManufacturerIfNotExists(context, xManufacturer);
var xLenses = xManufacturer.XPathSelectElements("lenses/lens");
CreateLensesIfNotExist(context, xLenses, manufacturer);
Console.WriteLine();
}
}
static void Main()
{
var context = new PhotographySystemEntities();
var albums = context.Albums
.Where(a => a.Photographs.Count > 1)
.OrderBy(a => a.Photographs.Count)
.ThenBy(a => a.Id)
.Select(a => new
{
id = a.Id,
name = a.Name,
owner = a.User.FullName,
photoCount = a.Photographs.Count
});
var result = JsonConvert.SerializeObject(albums, Formatting.Indented);
File.WriteAllText("albums.json", result);
}
static void Main(string[] args)
{
var context = new PhotographySystemEntities();
var manufcators = context.Manufacturers
.Select(m => new
{
manufacturer = m.Name,
cameras = m.Cameras.OrderBy(c => c.Model).Select(c => new
{
model = c.Model,
price = c.Price
}),
}).OrderBy(m => m.manufacturer);
// to use the jsSerializer we must import System.Web.Extensions from references
var json = new JavaScriptSerializer().Serialize(manufcators);
Console.WriteLine(json);
System.IO.File.WriteAllText(@"../../manufactureres-and-cameras.json", json);
}
public static void Main(string[] args)
{
var context = new PhotographySystemEntities();
var xml = XDocument.Load("../../../manufacturers-and-lenses.xml");
var manufacturers = xml.Root.Elements();
var processCounter = 0;
foreach (var node in manufacturers)
{
Console.WriteLine("Processing manufacturer #{0} ...", ++processCounter);
try
{
var manufacturer = ProcessManufacturer(context, node);
var lensesNode = node.Element("lenses");
if (lensesNode != null)
{
var lenses = lensesNode.Elements();
foreach (var lense in lenses)
{
try
{
ProcessLenses(context, lense, manufacturer);
}
catch (ArgumentException ex)
{
Console.Error.WriteLine("Processing lens terminated: {0}", ex.Message);
}
}
}
Console.WriteLine();
}
catch (ArgumentException ex)
{
Console.Error.WriteLine("Processing manufacture terminated: {0}", ex.Message);
}
}
}
static void Main()
{
var context = new PhotographySystemEntities();
var manufactureresAndCameras = context.Manufacturers
.OrderBy(m => m.Name)
.Select(m => new
{
manufacturer = m.Name,
cameras = m.Cameras
.OrderBy(c => c.Model)
.Select(c => new
{
model = c.Model,
price = c.Price
})
}).ToList();
var json = new JavaScriptSerializer().Serialize(manufactureresAndCameras);
//Console.WriteLine(json);
File.WriteAllText("../../manufactureres-and-cameras.json", json);
}
static void Main()
{
var context = new PhotographySystemEntities();
var manufacturers = context.Manufacturers
.OrderBy(m => m.Name)
.Select(m => new
{
manufacturer = m.Name,
cameras = m.Cameras.OrderBy(c => c.Model).Select(c => new
{
model = c.Model,
price = c.Price
})
}
);
var JSerializer = new JavaScriptSerializer();
var manufacturersAndModels = JSerializer.Serialize(manufacturers);
File.WriteAllText("../../manufactureres-and-cameras.json", manufacturersAndModels);
Console.WriteLine("File manufacturers-and-cameras.json exported.");
}
private static void Main(string[] args)
{
var context = new PhotographySystemEntities();
XmlDocument doc = new XmlDocument();
doc.Load("../../manufacturers-and-lenses.xml");
var root = doc.DocumentElement;
int id = 1;
foreach (XmlNode manufacturer in doc.DocumentElement)
{
Console.WriteLine("Processing # {0}", id++);
var manufacturerChilds = manufacturer.ChildNodes;
var manufacturerName = manufacturerChilds[0].InnerXml;
Manufacturer XmlManufacturer = new Manufacturer();
if (context.Manufacturers.Any(m => m.Name == manufacturerName))
{
Console.WriteLine("Existing manufacturer: {0}", manufacturerName);
}
else
{
Console.WriteLine("Created manufacturer: {0}", manufacturerName);
XmlManufacturer.Name = manufacturerName;
context.Manufacturers.Add(XmlManufacturer);
context.SaveChanges();
}
XmlNode lenses = manufacturerChilds[1];
if (lenses != null)
{
foreach (XmlNode lense in lenses)
{
string lenseModel = lense.Attributes["model"].Value;
string lenseType = lense.Attributes["type"].Value;
string lensePrice = lense.Attributes["price"] == null ? null : lense.Attributes["price"].Value;
if (context.Lenses.Any(l => l.Model == lenseModel))
{
Console.WriteLine("Existing lens: {0}", lenseModel);
}
else
{
Lens lens = new Lens()
{
Model = lenseModel,
Type = lenseType,
Price = lensePrice == null ? (decimal?)null : Decimal.Parse(lensePrice),
Manufacturer = context.Manufacturers.FirstOrDefault(m => m.Name == manufacturerName)
};
context.Lenses.Add(lens);
context.SaveChanges();
Console.WriteLine("Created lens: {0}", lenseModel);
}
}
}
Console.WriteLine();
}
}
static void Main()
{
var context = new PhotographySystemEntities();
var photographsQ = context.Photographs
.OrderBy(p => p.Title)
.Select(p => new
{
title = p.Title,
Category = p.Category.Name,
Link = p.Link,
Megapixels = p.Equipment.Camera.Megapixels,
CameraModel = p.Equipment.Camera.Manufacturer.Name + " " + p.Equipment.Camera.Model,
LensName = p.Equipment.Lens.Manufacturer.Name + " " + p.Equipment.Lens.Model,
LensPrice = p.Equipment.Lens.Price
}).ToList();
//foreach (var p in photographsQ)
//{
// Console.WriteLine(p.title);
// Console.WriteLine(p.Category);
// Console.WriteLine(p.Link);
// Console.WriteLine(p.Megapixels);
// Console.WriteLine(p.CameraModel);
// Console.WriteLine(p.LensName);
// Console.WriteLine(p.LensPrice);
// Console.WriteLine();
//}
XElement xmlPhotographs = new XElement("photographs");
foreach (var p in photographsQ)
{
XElement photograph = new XElement("photograph");
photograph.Add(new XAttribute("title", p.title));
var category = new XElement("category", p.Category);
photograph.Add(category);
photograph.Add(new XElement("link", p.Link));
var eq = new XElement("equipment");
eq.Add(new XElement("camera", new XAttribute("megapixels", p.Megapixels), p.CameraModel));
if (p.LensPrice != null)
{
var lens = new XElement("lens", new XAttribute("price", String.Format("{0:0.00}", p.LensPrice)), p.LensName);
eq.Add(lens);
}
else
{
var lens = new XElement("lens", p.LensName);
eq.Add(lens);
}
photograph.Add(eq);
xmlPhotographs.Add(photograph);
}
var xmlDoc = new XDocument(xmlPhotographs);
xmlDoc.Save("../../photographs.xml");
Console.WriteLine("Photographs exported to photographs.xml");
}
private static void ExportAlbumsAsXml(PhotographySystemEntities context)
{
var users = context.Users
.Where(u => u.Albums.Count >= 1)
.OrderBy(u => u.FullName)
.Select(u => new
{
id = u.Id,
birthdate = u.BirthDate,
albums = u.Albums
.Select(a => new
{
albumName = a.Name,
Description = a.Description,
photos = a.Photographs.Select(p => p.Title)
}),
camera = new
{
u.Equipment.Camera.Model,
u.Equipment.Camera.Megapixels,
Lens = u.Equipment.Lens.Model
},
});
var xmlDocument = new XElement("users");
foreach (var user in users)
{
var userNode = new XElement("user");
userNode.Add(new XAttribute("id", user.id));
userNode.Add(new XAttribute("birth-date", user.birthdate));
var albumNodes = new XElement("albums");
foreach (var album in user.albums)
{
var albumNode = new XElement("album");
albumNode.Add(new XAttribute("name", album.albumName));
if (album.Description != null)
{
albumNode.Add(new XAttribute("description", album.Description));
}
var photoNodes = new XElement("photographs");
foreach (var photo in album.photos)
{
var photoNode = new XElement("photo");
photoNode.Add(new XAttribute("title", photo));
photoNodes.Add(photoNode);
}
albumNode.Add(photoNodes);
albumNodes.Add(albumNode);
}
userNode.Add(albumNodes);
var cameraEl = new XElement("camera");
cameraEl.Add(new XAttribute("name", user.camera.Model));
cameraEl.Add(new XAttribute("megapixels", user.camera.Megapixels));
cameraEl.Add(new XAttribute("lens", user.camera.Lens));
userNode.Add(cameraEl);
xmlDocument.Add(userNode);
}
xmlDocument.Save("../../users.xml");
}
static void Main()
{
var context = new PhotographySystemEntities();
var usersData = context.Users
.Where(u => u.Albums.Any())
.OrderBy(u => u.FullName)
.Select(u => new
{
u.Id,
Albums = u.Albums
.Select(a => new
{
a.Name,
a.Description,
Photographs = a.Photographs
.Select(p => p.Title)
}),
u.BirthDate,
Camera = new
{
u.Equipment.Camera.Model,
u.Equipment.Camera.Megapixels,
Lens = u.Equipment.Lens.Model
}
});
XElement root = new XElement("users");
foreach (var user in usersData)
{
var xUser = new XElement("user");
xUser.Add(new XAttribute("id", user.Id));
xUser.Add(new XAttribute("birth-date", user.BirthDate));
var xAlbumCollection = new XElement("albums");
foreach (var album in user.Albums)
{
var xAlbum = new XElement("album");
xAlbum.Add(new XAttribute("name", album.Name));
if (album.Description != null)
{
xAlbum.Add(new XAttribute("description", album.Description));
}
var xPhotographCollection = new XElement("photographs");
foreach (var photograph in album.Photographs)
{
var xPhotograph = new XElement("photograph");
xPhotograph.Add(new XAttribute("title", photograph));
xPhotographCollection.Add(xPhotograph);
}
xAlbum.Add(xPhotographCollection);
xAlbumCollection.Add(xAlbum);
}
xUser.Add(xAlbumCollection);
var xCamera = new XElement("camera");
xCamera.Add(new XAttribute("model", user.Camera.Model));
xCamera.Add(new XAttribute("lens", user.Camera.Lens));
xCamera.Add(new XAttribute("megapixels", user.Camera.Megapixels));
xUser.Add(xCamera);
root.Add(xUser);
}
root.Save("users.xml");
}
public static void Main(string[] args)
{
var context = new PhotographySystemEntities();
var rng = new Random();
var doc = XDocument.Load("../../../generate-equipments.xml");
var generate = doc.Root.Elements();
var processCount = 0;
foreach (var element in generate)
{
Console.WriteLine("Processing request #{0} ...", ++processCount);
var generateCountNode = element.Attribute("generate-count");
var generateCunt = 10;
if (generateCountNode != null)
{
generateCunt = int.Parse(generateCountNode.Value);
}
var manufacturerNode = element.Element("manufacturer");
var manufacturer = "Nikon";
if (manufacturerNode != null)
{
manufacturer = manufacturerNode.Value;
}
var cameras = context.Cameras
.Where(c => c.Manufacturer.Name == manufacturer)
.Select(c => c.Id)
.ToList();
var lens = context.Lenses
.Where(c => c.Manufacturer.Name == manufacturer)
.Select(c => c.Id)
.ToList();
var users = context.Users.Select(u => u.Id).ToList();
var photos = context.Photographs.Select(p => p.Id).ToList();
for (int i = 0; i < generateCunt; i++)
{
var userNumber = rng.Next(0, users.Count);
var usersList = new List <User>();
for (int j = 0; j < userNumber; j++)
{
usersList.Add(context.Users.Find(users[rng.Next(0, users.Count)]));
}
var photoNumber = rng.Next(0, users.Count);
var photosList = new List <Photograph>();
for (int j = 0; j < photoNumber; j++)
{
photosList.Add(context.Photographs.Find(photos[rng.Next(0, photos.Count)]));
}
var equipment = new Equipment()
{
Camera = context.Cameras.Find(cameras[rng.Next(0, cameras.Count())]),
Lens = context.Lenses.Find(lens[rng.Next(0, lens.Count())]),
Users = usersList,
Photographs = photosList
};
context.Equipments.Add(equipment);
context.SaveChanges();
Console.WriteLine("Equipment added: {0} (Camera: {1} - Lens: {2})",
manufacturer,
equipment.Camera.Model,
equipment.Lens.Model);
}
Console.WriteLine();
}
}
static void Main()
{
var context = new PhotographySystemEntities();
var xml = XDocument.Load(XmlPath);
var xManufacturers = xml.XPathSelectElements("manufacturers/manufacturer");
foreach (var xManufacturer in xManufacturers)
{
var manufacturer = new Manufacturer();
var manufacturerName = xManufacturer.Attribute("name").Value;
var exists = context.Manufacturers.Any(m => m.Name == manufacturerName);
if (exists)
{
Console.WriteLine("Manufacturer {0} already exists.",
manufacturerName);
continue;
}
manufacturer.Name = manufacturerName;
var xCameras = xManufacturer.XPathSelectElements("cameras/camera");
foreach (var xCamera in xCameras)
{
var camera = new Camera();
camera.Model = xCamera.Attribute("model").Value;
camera.Year = int.Parse(xCamera.Attribute("year").Value);
if (xCamera.Attribute("megapixels") != null)
{
camera.Megapixels = int.Parse(xCamera.Attribute("megapixels").Value);
}
if (xCamera.Attribute("price") != null)
{
camera.Price = decimal.Parse(xCamera.Attribute("price").Value);
}
manufacturer.Cameras.Add(camera);
}
var xLenses = xManufacturer.XPathSelectElements("lenses/lens");
foreach (var xLens in xLenses)
{
var lens = new Lens();
lens.Model = xLens.Attribute("model").Value;
lens.Type = xLens.Attribute("type").Value;
if (xLens.Attribute("price") != null)
{
lens.Price = decimal.Parse(xLens.Attribute("price").Value);
}
manufacturer.Lenses.Add(lens);
}
context.Manufacturers.Add(manufacturer);
context.SaveChanges();
Console.WriteLine("Successfully added manufacturer {0}.",
manufacturerName);
}
}
