private string SaveXElement(object elem, SaveOptions so)
 {
     string retVal = null;
     switch (_mode)
     {
         case "Save":
             using (StringWriter sw = new StringWriter())
             {
                 if (_type.Name == "XElement")
                 {
                     (elem as XElement).Save(sw, so);
                 }
                 else if (_type.Name == "XDocument")
                 {
                     (elem as XDocument).Save(sw, so);
                 }
                 retVal = sw.ToString();
             }
             break;
         case "ToString":
             if (_type.Name == "XElement")
             {
                 retVal = (elem as XElement).ToString(so);
             }
             else if (_type.Name == "XDocument")
             {
                 retVal = (elem as XDocument).ToString(so);
             }
             break;
         default:
             TestLog.Compare(false, "TEST FAILED: wrong mode");
             break;
     }
     return retVal;
 }

		public override int SaveChanges(SaveOptions options)
		{
			BeforeSaveChanges(this);
			var result = base.SaveChanges(options);
			AfterSaveChanges(this);
			return result;
		}

 ///<summary>
 /// Tidies the XML file by formatting it in alphabetical order.
 ///</summary>
 ///<param name="inputXml"></param>
 ///<param name="saveOptions">Allows choosing between formatted/non-formatter output</param>
 ///<returns></returns>
 public string Tidy(string inputXml, SaveOptions saveOptions)
 {
     var xmlDoc = XDocument.Parse(inputXml,LoadOptions.PreserveWhitespace);
     var first = xmlDoc.Elements().First();
     first.ReplaceWith(GetOrderedElement(first));
     return xmlDoc.Declaration + xmlDoc.ToString(saveOptions);
 }

        // ExStart:PrefixForFontsHelper
        private static string CustomResourcesProcessing(SaveOptions.ResourceSavingInfo resourceSavingInfo)
        {
            //-----------------------------------------------------------------------------
            // It's just example of possible realization of cusstom processing of resources
            // Referenced in result HTML
            //-----------------------------------------------------------------------------

            // 1) In this case we need only do something special
            //    with fonts, so let's leave processing of all other resources
            //    to converter itself
            if (resourceSavingInfo.ResourceType != SaveOptions.NodeLevelResourceType.Font)
            {
                resourceSavingInfo.CustomProcessingCancelled = true;
                return "";
            }

            // If supplied font resource, process it ourselves
            // 1) Write supplied font with short name  to desired folder
            //    You can easily do anythings  - it's just one of realizations

            _fontNumberForUniqueFontFileNames++;
            string shortFontFileName = (_fontNumberForUniqueFontFileNames.ToString() + Path.GetExtension(resourceSavingInfo.SupposedFileName));
            string outFontPath = _desiredFontDir + "\\" + shortFontFileName;

            System.IO.BinaryReader fontBinaryReader = new BinaryReader(resourceSavingInfo.ContentStream);
            System.IO.File.WriteAllBytes(outFontPath, fontBinaryReader.ReadBytes((int)resourceSavingInfo.ContentStream.Length));


            // 2) Return the desired URI with which font will be referenced in CSSes
            string fontUrl = "http:// Localhost:255/document-viewer/GetFont/" + shortFontFileName;
            return fontUrl;
        }

        public override int SaveChanges(SaveOptions options)
        {
            foreach (ObjectStateEntry entry in
                ObjectStateManager.GetObjectStateEntries(
                EntityState.Added | EntityState.Modified))
            {
                if (entry.Entity is Configuration)
                {
                    ValidateConfigurationAggregate((Configuration)entry.Entity);
                }
                else if (entry.Entity is Payment)
                {

                    ValidatePaymentAggregate((Payment)entry.Entity);

                    if (entry.State == EntityState.Added)
                    {
                        Payment payment = (Payment)entry.Entity;
                        payment.PaymentCode = PaymentCode.NextPaymentCode(this);
                    }
                }
            }

            return base.SaveChanges(options);
        }

        private static string CustomSaveOfFontsAndImages(SaveOptions.ResourceSavingInfo resourceSavingInfo)
        {
            System.IO.BinaryReader reader = new BinaryReader(resourceSavingInfo.ContentStream);
            byte[] resourceAsBytes = reader.ReadBytes((int)resourceSavingInfo.ContentStream.Length);

            if (resourceSavingInfo.ResourceType == SaveOptions.NodeLevelResourceType.Font)
            {
                Console.WriteLine("Font processed with handler. Length of content in bytes is " + resourceAsBytes.Length.ToString());
                // Here You can put code that will save font to some storage, f.e database
                MemoryStream targetStream = new MemoryStream();
                targetStream.Write(resourceAsBytes, 0, resourceAsBytes.Length);
            }
            else if (resourceSavingInfo.ResourceType == SaveOptions.NodeLevelResourceType.Image)
            {
                Console.WriteLine("Image processed with handler. Length of content in bytes is " + resourceAsBytes.Length.ToString());
                // Here You can put code that will save image to some storage, f.e database
                MemoryStream targetStream = new MemoryStream();
                targetStream.Write(resourceAsBytes, 0, resourceAsBytes.Length);
            }

            // We should return URI bt which resource will be referenced in CSS(for font)
            // Or HTML(for images)
            //  This  is very siplistic way - here we just return file name or resource.
            //  You can put here some URI that will include ID of resource in database etc. 
            //  - this URI will be added into result CSS or HTML to refer the resource
            return resourceSavingInfo.SupposedFileName;
        }

 public override int SaveChanges(SaveOptions options)
 {
     int returnValue = 0;
     // 因为我们不调用base.SaveChanges, 我们必须手动关闭链接.
     // 否则我们将留下许多打开的链接, 最终导致链接瓶颈.
     // Entity Framework提供了base.SaveChanges内部使用的EnsureConnection和ReleaseConnection.
     // 这些是内部方法, 所以我们必须使用反射调用它们.
     var EnsureConnectionMethod = typeof(ObjectContext).GetMethod(
         "EnsureConnection", BindingFlags.Instance | BindingFlags.NonPublic);
     EnsureConnectionMethod.Invoke(this, null);
     // 使用ObjectStateManager.GetObjectStateEntries完成增加,修改,和删除集合.
     foreach (ObjectStateEntry ose in this.ObjectStateManager.GetObjectStateEntries(EntityState.Added))
     {
         Travel travel = ose.Entity as Travel;
         if (travel != null)
         {
             RetryPolicy retryPolicy = new RetryPolicy();
             retryPolicy.Task = new Action(() =>
             {
                 this.InsertIntoTravel(travel.PartitionKey,
                     travel.Place, travel.GeoLocationText, travel.Time);
             });
             retryPolicy.Execute();
             returnValue++;
         }
     }
     foreach (ObjectStateEntry ose in this.ObjectStateManager.GetObjectStateEntries(EntityState.Modified))
     {
         Travel travel = ose.Entity as Travel;
         if (travel != null)
         {
             RetryPolicy retryPolicy = new RetryPolicy();
             retryPolicy.Task = new Action(() =>
             {
                 this.UpdateTravel(travel.PartitionKey,
                     travel.RowKey, travel.Place, travel.GeoLocationText, travel.Time);
             });
             retryPolicy.Execute();
             returnValue++;
         }
     }
     foreach (ObjectStateEntry ose in this.ObjectStateManager.GetObjectStateEntries(EntityState.Deleted))
     {
         Travel travel = ose.Entity as Travel;
         if (travel != null)
         {
             RetryPolicy retryPolicy = new RetryPolicy();
             retryPolicy.Task = new Action(() =>
             {
                 this.DeleteFromTravel(travel.PartitionKey, travel.RowKey);
             });
             retryPolicy.Execute();
             returnValue++;
         }
     }
     var ReleaseConnectionMethod = typeof(ObjectContext).
         GetMethod("ReleaseConnection", BindingFlags.Instance | BindingFlags.NonPublic);
     ReleaseConnectionMethod.Invoke(this, null);
     return returnValue;
 }

		public override int SaveChanges(SaveOptions options) {
			foreach(ObjectStateEntry objectStateEntry in ObjectStateManager.GetObjectStateEntries(EntityState.Added)) {
				if(objectStateEntry.Entity is Event) {
					((Event)objectStateEntry.Entity).BeforeSave();
				}
			}
			return base.SaveChanges(options);
		}

 public void SaveChanges(SaveOptions saveOptions)
 {
     if (IsInTransaction)
     {
         throw new ApplicationException("A transaction is currently open. Use RollBackTransaction or CommitTransaction instead.");
     }
     ((IObjectContextAdapter)_dbContext).ObjectContext.SaveChanges(saveOptions);
 }

		/// <summary>
		///   Преобразовать документ в XML-строку
		/// </summary>
		/// <param name="document"> Документ </param>
		/// <param name="encoding"> Кодировка документа </param>
		/// <param name="options"> Опции сохранения </param>
		/// <returns> </returns>
		public static string ToXml(this XDocument document, Encoding encoding, SaveOptions options)
		{
			using (var writer = new EncodedStringWriter(encoding))
			{
				document.Save(writer, options);
				return writer.ToString();
			}
		}

        public int SaveChanges(SaveOptions options, bool logChanges)
        {
            int result = base.SaveChanges(options);

            if(SavedChanges != null)
                SavedChanges(this, null);

            return result;
        }

        public override int SaveChanges(SaveOptions options)
        {
            int result = base.SaveChanges(options);

            if (SavedChanges != null)
                SavedChanges(this, new EventArgs());

            return result;
        }

    public void SaveChanges(SaveOptions saveOptions)
    {
      if (IsInTransaction)
      {
        throw new ApplicationException("A transaction is running. Call CommitTransaction instead.");
      }

      ((IObjectContextAdapter)_dbContext).ObjectContext.SaveChanges(saveOptions);
    }

 public override int SaveChanges(SaveOptions options)
 {
     var changes = ObjectStateManager.GetObjectStateEntries(EntityState.Unchanged);
     foreach (var change in changes)
     {
         var entityWithId = change.Entity as EntityWithId;
         if (entityWithId != null)
             ChangeStateOfEntity(ObjectStateManager, entityWithId);
     }
     return base.SaveChanges(options);
 }

		public string ToString (SaveOptions options)
		{
			StringWriter sw = new StringWriter ();
			XmlWriterSettings s = new XmlWriterSettings ();
			s.ConformanceLevel = ConformanceLevel.Auto;
			s.Indent = options != SaveOptions.DisableFormatting;
			XmlWriter xw = XmlWriter.Create (sw, s);
			WriteTo (xw);
			xw.Close ();
			return sw.ToString ();
		}

        /// <summary>
        /// 把 XElement 转换为 XML 格式的字符串
        /// </summary>
        /// <param name="rootElement"></param>
        /// <param name="saveOptions"></param>
        /// <returns></returns>
        public static string ToXmlText(this XElement rootElement, SaveOptions saveOptions)
        {
            XDocument xdoc = new XDocument(rootElement);
            xdoc.Declaration = new XDeclaration("1.0", "gb2312", null);

            MemoryStream htmlStream = new MemoryStream();
            xdoc.Save(htmlStream, saveOptions);

            string htmlText = Encoding.GetEncoding("GB2312").GetString(htmlStream.ToArray());
            htmlStream.Close();

            return htmlText;
        }

        public override int SaveChanges(SaveOptions options)
        {
            var si = SessionInfo.Get();
            if (sharedClient != null && si.currentTopicId != -1 && si.discussion != null)
            {
                //added
                foreach (ObjectStateEntry entry in ObjectStateManager.GetObjectStateEntries(EntityState.Added))
                {
                    if (entry.Entity is ArgPoint)
                    {
                        ((ArgPoint) entry.Entity).ChangesPending = false;
                        sharedClient.clienRt.SendStatsEvent(StEvent.BadgeCreated,
                                                            si.person.Id, si.discussion.Id, si.currentTopicId,
                                                            DeviceType.Wpf);
                    }
                }

                //edited
                foreach (ObjectStateEntry entry in ObjectStateManager.GetObjectStateEntries(EntityState.Modified))
                {
                    if (entry.Entity is ArgPoint)
                    {
                        ((ArgPoint) entry.Entity).ChangesPending = false;
                        sharedClient.clienRt.SendStatsEvent(StEvent.BadgeEdited,
                                                            SessionInfo.Get().person.Id,
                                                            si.discussion.Id,
                                                            si.currentTopicId,
                                                            DeviceType.Wpf);
                    }
                }

                //sources/comments/media modified
                foreach (ObjectStateEntry entry in ObjectStateManager.GetObjectStateEntries(EntityState.Unchanged))
                {
                    if (entry.Entity is ArgPoint)
                    {
                        var ap = (ArgPoint) entry.Entity;
                        if (ap.ChangesPending)
                        {
                            ap.ChangesPending = false;
                            sharedClient.clienRt.SendStatsEvent(StEvent.BadgeEdited,
                                                                si.person.Id, si.discussion.Id, si.currentTopicId,
                                                                DeviceType.Wpf);
                        }
                    }
                }
            }

            return base.SaveChanges(options);
        }

        // ExStart:PrefixForURLsHelper
        private static string Custom_processor_of_embedded_images(SaveOptions.ResourceSavingInfo resourceSavingInfo)
        {
            // ____________________________________________________________________________
            //    This sample method saving strategy method saves image-files in some folder
            //    (including raster image files that are exctracted from that SVGs)
            //    Then it returns specific custom artificial  path
            //    to be used as value of 'src' or 'data' relevant attribute in generated host-SVG(or HTML)
            // ____________________________________________________________________________

            //---------------------------------------------------------
            // 1) All other files(f.e. fonts) will be processed with converter itself cause for them flag
            //   resourceSavingInfo.CustomProcessingCancelled is set to 'true'
            //---------------------------------------------------------
            if (!(resourceSavingInfo is HtmlSaveOptions.HtmlImageSavingInfo))
            {
                resourceSavingInfo.CustomProcessingCancelled = true;
                return "";
            }
            //---------------------------------------------------------
            // 1) Create target folder if not created yet
            //---------------------------------------------------------
            string dataDir = RunExamples.GetDataDir_AsposePdf_DocumentConversion_PDFToHTMLFormat();
            string outDir = dataDir + @"output\36297_files\";
            string outPath = outDir + Path.GetFileName(resourceSavingInfo.SupposedFileName);
            if (!Directory.Exists(outDir))
            {
                Directory.CreateDirectory(outDir);
            }
            //---------------------------------------------------------
            // 3) Write supplied image to that folder
            //---------------------------------------------------------
            System.IO.BinaryReader reader = new BinaryReader(resourceSavingInfo.ContentStream);
            System.IO.File.WriteAllBytes(dataDir, reader.ReadBytes((int)resourceSavingInfo.ContentStream.Length));
            //---------------------------------------------------------
            // 4) Return customized specific URL to be used to refer
            //    just created image in parent SVG (or HTML)
            //---------------------------------------------------------
            HtmlSaveOptions.HtmlImageSavingInfo asHtmlImageSavingInfo = resourceSavingInfo as HtmlSaveOptions.HtmlImageSavingInfo;
            if (asHtmlImageSavingInfo.ParentType == HtmlSaveOptions.ImageParentTypes.SvgImage)
            {
                return "http:// Localhost:255/" + resourceSavingInfo.SupposedFileName;
            }
            else
            {
                return "http:// Localhost:GetImage/imageID=" + resourceSavingInfo.SupposedFileName;
            }
        }

        public static HttpContent ToContent(this XElement element, SaveOptions options = SaveOptions.None)
        {
            FX.ThrowIfNull(element, "element");

            var stream = new MemoryStream();
            try
            {
                element.Save(stream, options);
                stream.Position = 0;
                var content = new StreamContent(stream);
                return content;
            }
            catch
            {
                stream.Dispose();
                throw;
            }
        }

        public override int SaveChanges(SaveOptions options)
        {
            var changes = this.ObjectStateManager.GetObjectStateEntries(
                                 EntityState.Modified |
                                 EntityState.Added |
                                 EntityState.Deleted);
            foreach (var change in changes) {
                var entity = change.Entity as IEntityTracking;
                if (entity != null) {
                    if (change.State == EntityState.Deleted) {
                        change.ChangeState(EntityState.Modified);
                        entity.IsDeleted = true;
                    }
                    entity.LastUpdated = DateTime.Now.Ticks;
                }
            }

            return base.SaveChanges(options);
        }