private Route CreateGpx_1_1_Route(XDocument routeDocument, XNamespace ns)
        {
            XElement track = routeDocument.Root.Element(ns + "trk");
            string name = track.Element(ns + "name").Value;

            Route newRoute = new Route {Name = name, DateCreated = DateTime.Now};
            List<RoutePoint> routePoints = new List<RoutePoint>();
            var trackPoints = track.Descendants(ns + "trkpt");
            foreach (XElement trackPoint in trackPoints)
            {
                RoutePoint routePoint = new RoutePoint();
                routePoint.Latitude = double.Parse(trackPoint.Attribute("lat").Value);
                routePoint.Longitude = double.Parse(trackPoint.Attribute("lon").Value);
                routePoint.Elevation = double.Parse(trackPoint.Element(ns + "ele").Value);
                routePoint.TimeRecorded = DateTime.Parse(trackPoint.Element(ns + "time").Value);
                routePoints.Add(routePoint);
            }
            routePoints = routePoints.OrderBy(rp => rp.TimeRecorded).ToList();
            int index = 0;
            foreach (RoutePoint routePoint in routePoints)
            {
                routePoint.SequenceIndex = index;
                index++;
            }
            newRoute.RoutePoints = routePoints;
            newRoute.Distance = CalculateDistance(newRoute.RoutePoints);
            Tuple<double, double> ascentDescent = CalculateAscentDescent(newRoute.RoutePoints);
            newRoute.TotalAscent += ascentDescent.Item1;
            newRoute.TotalDescent += ascentDescent.Item2;
            return newRoute;
        }

        public static ObservableCollection<GanttTask> GetMsTasks(XDocument xDocument, XNamespace xnamespace)
        {
            var allTasks = new ObservableCollection<GanttTask>();
            var task = xDocument.Root.Elements(xnamespace + "Tasks");
            var tasks = task.Elements(xnamespace + "Task");
            tasks.FirstOrDefault().Remove();
            PrepareXMLTasksForConvertingToGanttTasks(xnamespace, tasks);
            GenerateAllGanttTasks(tasks, xnamespace);

            foreach (var t in taskIdToGanttTask)
            {
                var gtask = t.Value.Item1;

                SetUpRelationsToGanttTask(t.Key, t.Value, gtask);

                var oNumber = t.Value.Item2;
                if (oNumber != null)
                {
                    SetUpChildrenToGanttTask(t.Value, gtask);

                }
                if (IsRootTask(oNumber))
                {
                    allTasks.Add(gtask);
                }
            }
            return allTasks;
        }

 private CorrelationKey(string keyString, XNamespace provider) : base(GenerateKey(keyString), dictionary)
 {
     Dictionary<XName, InstanceValue> dictionary = new Dictionary<XName, InstanceValue>(2);
     dictionary.Add(provider.GetName("KeyString"), new InstanceValue(keyString, InstanceValueOptions.Optional));
     dictionary.Add(WorkflowNamespace.KeyProvider, new InstanceValue(provider.NamespaceName, InstanceValueOptions.Optional));
     this.KeyString = keyString;
 }

 public UPnPService(UPnPDevice parent, XNamespace ns, XElement service)
 {
     ParentDevice = parent;
       ServiceType = service.Elements().First(e => e.Name.LocalName == "serviceType").Value;
       ServiceID = service.Elements().First(e => e.Name.LocalName == "serviceId").Value;
       ControlUrl = service.Elements().First(e => e.Name.LocalName == "controlURL").Value;
 }

 internal static void UpdateXElement(this XElement element, SettingsInfo settings, XNamespace ns)
 {
     element.Attribute("ID").Value = settings.Id.ToString();
     element.Attribute("processorRef").Value = settings.Processor.Id.ToString();
     element.Element(ns + "name").Value = settings.Name;
     element.Element(ns + "serialPortSettings").UpdateXElement(settings.SerialPortSettings, ns);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="xmlns"></param>
 /// <returns></returns>
 public override XElement CreateElement(XNamespace xmlns)
 {
     return new XElement(xmlns + "channel")
         .AddElement(xmlns + "title", Title)
         .AddElement(xmlns + "link", Link)
         .AddElement(xmlns + "description", Description);
 }

        public EpubSummaryParser(Stream source)
        {
            _zip = ZipContainer.Unzip(source);
            XDocument xmlDocument = _zip.GetFileStream("META-INF/container.xml").GetXmlDocument();
            XElement root = xmlDocument.Root;
            if (root == null)
                throw new DataException(InvalidEpubMetaInfo);

            XAttribute attribute = root.Attribute("xmlns");
            XNamespace xmlns = (attribute != null) ? XNamespace.Get(attribute.Value) : XNamespace.None;
            XAttribute fullPath = xmlDocument.Descendants(xmlns + "rootfile").First().Attribute("full-path");
            if (fullPath == null)
                throw new DataException(InvalidEpubMetaInfo);

            string path = fullPath.Value;
            _opfPath = path;
            _opf = _zip.GetFileStream(path).GetXmlDocument();
            _opfRoot = _opf.Root;
            if (_opfRoot == null)
                throw new DataException(InvalidEpubMetaInfo);

            _oebps = GetPath(path);
            _opfns = XNamespace.Get("http://www.idpf.org/2007/opf");
            _opfdc = XNamespace.Get("http://purl.org/dc/elements/1.1/");

            _coverHelper = new EpubCoverHelper(_zip, _opfns, _opfRoot, _oebps);
        }

		public static XElement XElementFromElastic(ElasticObject elastic, XNamespace nameSpace = null)
		{
			// we default to empty namespace
			nameSpace = nameSpace ?? string.Empty;
			var exp = new XElement(nameSpace + elastic.InternalName);

			foreach (var a in elastic.Attributes.Where(a => a.Value.InternalValue != null))
			{
				// if we have xmlns attribute add it like XNamespace instead of regular attribute
				if (a.Key.Equals("xmlns", StringComparison.InvariantCultureIgnoreCase))
				{
					nameSpace = a.Value.InternalValue.ToString();
					exp.Name = nameSpace.GetName(exp.Name.LocalName);
				}
				else
				{
					exp.Add(new XAttribute(a.Key, a.Value.InternalValue));
				}
			}

			if (elastic.InternalContent is string)
			{
				exp.Add(new XText(elastic.InternalContent as string));
			}

			foreach (var child in elastic.Elements.Select(c => XElementFromElastic(c, nameSpace)))
			{
				exp.Add(child);
			}

			return exp;
		}

 //private String Method;
 //private String ApiTimeStamp;
 public ActiveForm(XNamespace ns, String ApiKey, String SecretApiKey)
 {
     this.NameSpace = ns;
       this.ApiKey = ApiKey;
       this.SecretApiKey = SecretApiKey;
       BaseUrl = "https://api.activeforms.com/4.0/";
 }

 internal SchemaInfo(IFormChannelIdentifier channelIdentifier, XNamespace namespaceObj, XDocument schema)
 {
     this.ChannelIdentifier = channelIdentifier;
     this.Namespace = namespaceObj;
     this.Schema = schema;
     this.SchemaType = FormSchemaType.Uicontrols;
 }

 public static string GetAvailability(this XElement xElement, XNamespace ns)
 {
     return xElement.Element(ns + "Offers") == null ? string.Empty :
         xElement.Element(ns + "Offers").Element(ns + "Offer") == null ? string.Empty :
         xElement.Element(ns + "Offers").Element(ns + "Offer").Element(ns + "OfferListing") == null ? string.Empty :
         xElement.Element(ns + "Offers").Element(ns + "Offer").Element(ns + "OfferListing").ElementValue("Availability", ns);
 }

		static XNamespace ()
		{
			nstable = new Dictionary<string, XNamespace> ();
			blank = Get (String.Empty);
			xml = Get ("http://www.w3.org/XML/1998/namespace");
			xmlns = Get ("http://www.w3.org/2000/xmlns/");
		}

 public static void SetDefaultXmlNamespace(this XElement xelem, XNamespace xmlns)
 {
     if (xelem.Name.NamespaceName == string.Empty)
         xelem.Name = xmlns + xelem.Name.LocalName;
     foreach (var e in xelem.Elements())
         e.SetDefaultXmlNamespace(xmlns);
 }

 private static void GenerateAllGanttTasks(IEnumerable<XElement> tasks, XNamespace xnamespace)
 {
     foreach (var t in tasks)
     {
         var ganttTask = new GanttTask();
         if (t.Element(xnamespace + "Name") != null)
         {
             ganttTask.Title = t.Element(xnamespace + "Name").Value;
         }
         ganttTask.UniqueId = t.Element(xnamespace + "UID").Value;
         ganttTask.Start = DateTime.Parse(t.Element(xnamespace + "Start").Value);
         ganttTask.End = DateTime.Parse(t.Element(xnamespace + "Finish").Value);
         ganttTask.IsMilestone = t.Element(xnamespace + "Milestone").Value == "1";
         ganttTask.Progress = Double.Parse(t.Element(xnamespace + "PercentComplete").Value);
         string outlineNumber = null;
         if (t.Element(xnamespace + "OutlineNumber") != null)
         {
             outlineNumber = t.Element(xnamespace + "OutlineNumber").Value;
         }
         var relations = t.Elements(xnamespace + "PredecessorLink");
         IList<string> relatonTaskIDs = new List<string>();
         foreach (var relation in relations)
         {
             var relationTask = relation.Element(xnamespace + "PredecessorUID").Value;
             relatonTaskIDs.Add(relationTask);
         }
         if (outlineNumber != null)
         {
             SetAllChildren(outlineNumber, ganttTask.UniqueId);
         }
         taskIdToGanttTask[ganttTask.UniqueId] = new Tuple<GanttTask, string>(ganttTask, outlineNumber);
     }
 }

 public objXmlEdmx(String strFilename)
     : base(strFilename)
 {
     this.strEdmxNs = XNamespace.Get(ConfigurationManager.AppSettings["EdmxNs"]);
     this.strSchemaNs = XNamespace.Get(ConfigurationManager.AppSettings["EdmxSchemaNs"]);
     InitRuntime();
 }

        private static void CreateNodes(XNamespace ns, XElement nodes, DgmlNode dgmlNode)
        {
            XElement node;
            if (dgmlNode.Category == "SyntaxToken")
            {
                node = new XElement(ns + "Node",
                    new XAttribute("Id", dgmlNode.Id),
                    new XAttribute("Category", dgmlNode.Category),
                    new XAttribute("Label", dgmlNode.Label));
            }
            else
            {
                node = new XElement(ns + "Node",
                    new XAttribute("Id", dgmlNode.Id),
                    new XAttribute("Category", dgmlNode.Category),
                    new XAttribute("Label", dgmlNode.Kind));
            }

            nodes.Add(node);

            foreach (var childNode in dgmlNode.Childs)
            {
                CreateNodes(ns, nodes, childNode);
            }
        }

        static void Main(string[] args)
        {
            doc = XDocument.Load("http://events.feed.comportal.be/agenda.aspx?event=TechDays&year=2013&speakerlist=c|Experts");

            jsonns = "http://james.newtonking.com/projects/json";
            doc.Root.SetAttributeValue(XNamespace.Xmlns + "json", jsonns);

            CleanSection("bio");
            CleanSection("description");

            ToJsonArray("timeslot");
            ToJsonArray("session");
            ToJsonArray("tag");
            ToJsonArray("speaker");

            var wrdoc = File.CreateText("sessions.xml");
            wrdoc.Write(doc);
            wrdoc.Close();

            var jsonstring = JsonConvert.SerializeXNode(doc);

            var wr = File.CreateText("sessions.json");
            wr.Write(jsonstring);
            wr.Close();

            var rdr = File.OpenText("sessions.json");
            var json = rdr.ReadToEnd();
            rdr.Close();

            var theevent = JsonConvert.DeserializeObject<TopXml>(json);

            //Console.WriteLine("done");
            //Console.ReadLine();
        }

        /// <summary>
        /// Gets the prefix associated with a namespace for this <see cref="XDocument"/>.
        /// </summary>
        /// <param name="self"></param>
        /// <param name="ns"></param>
        /// <returns></returns>
        public static string GetPrefixOfNamespace(this XDocument self, XNamespace ns)
        {
            Contract.Requires<ArgumentNullException>(self != null);
            Contract.Requires<ArgumentNullException>(ns != null);

            return self.Root.GetPrefixOfNamespace(ns);
        }

 public static string GetOfferListingId(this XElement xElement, XNamespace ns)
 {
     return xElement.Element(ns + "Offers") == null? string.Empty : xElement.Element(ns + "Offers").Elements(ns + "Offer") == null ? string.Empty :
             xElement.Element(ns + "Offers").Elements(ns + "Offer").Elements(ns + "OfferListing") == null ? string.Empty :
             xElement.Element(ns + "Offers").Elements(ns + "Offer").Elements(ns + "OfferListing").Descendants(ns + "OfferListingId") == null ? string.Empty : 
             xElement.Element(ns + "Offers").Elements(ns + "Offer").Elements(ns + "OfferListing").Descendants(ns + "OfferListingId").Select(f => f == null ? string.Empty : f.Value).First().ToString();
 }

 public void FixSize(XNamespace ab, XElement role, string name, string size)
 {
     foreach (var local in role.Elements(ab + "LocalResources"))
         foreach (var storage in local.Elements(ab + "LocalStorage"))
             if (storage.Attribute("name").Value == name)
                 storage.SetAttributeValue("sizeInMB", size);
 }