class Program
    {
        static void Main(string[] args)
        {
            foreach (string s in GetAllTextInSlide(@"..\..\Documents\Myppt8.pptx", 1))
                Console.WriteLine(s);
        }
        // Get all the text in a slide.
        public static string[] GetAllTextInSlide(string presentationFile, int slideIndex)
        {
            // Open the presentation as read-only.
            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, false))
            {
                // Pass the presentation and the slide index
                // to the next GetAllTextInSlide method, and
                // then return the array of strings it returns. 
                return GetAllTextInSlide(presentationDocument, slideIndex);
            }
        }
        public static string[] GetAllTextInSlide(PresentationDocument presentationDocument, int slideIndex)
        {
            // Verify that the presentation document exists.
            if (presentationDocument == null)
            {
                throw new ArgumentNullException("presentationDocument");
            }

            // Verify that the slide index is not out of range.
            if (slideIndex < 0)
            {
                throw new ArgumentOutOfRangeException("slideIndex");
            }

            // Get the presentation part of the presentation document.
            PresentationPart presentationPart = presentationDocument.PresentationPart;

            // Verify that the presentation part and presentation exist.
            if (presentationPart != null && presentationPart.Presentation != null)
            {
                // Get the Presentation object from the presentation part.
                Presentation presentation = presentationPart.Presentation;

                // Verify that the slide ID list exists.
                if (presentation.SlideIdList != null)
                {
                    // Get the collection of slide IDs from the slide ID list.
                    DocumentFormat.OpenXml.OpenXmlElementList slideIds =
                        presentation.SlideIdList.ChildElements;

                    // If the slide ID is in range...
                    if (slideIndex < slideIds.Count)
                    {
                        // Get the relationship ID of the slide.
                        string slidePartRelationshipId = (slideIds[slideIndex] as SlideId).RelationshipId;

                        // Get the specified slide part from the relationship ID.
                        SlidePart slidePart =
                            (SlidePart)presentationPart.GetPartById(slidePartRelationshipId);

                        // Pass the slide part to the next method, and
                        // then return the array of strings that method
                        // returns to the previous method.
                        return GetAllTextInSlide(slidePart);
                    }
                }
            }

            // Else, return null.
            return null;
        }
        public static string[] GetAllTextInSlide(SlidePart slidePart)
        {
            // Verify that the slide part exists.
            if (slidePart == null)
            {
                throw new ArgumentNullException("slidePart");
            }

            // Create a new linked list of strings.
            LinkedList texts = new LinkedList();

            // If the slide exists...
            if (slidePart.Slide != null)
            {
                // Iterate through all the paragraphs in the slide.
                foreach (DocumentFormat.OpenXml.Drawing.Paragraph paragraph in
                    slidePart.Slide.Descendants())
                {
                    // Create a new string builder.                    
                    StringBuilder paragraphText = new StringBuilder();

                    // Iterate through the lines of the paragraph.
                    foreach (DocumentFormat.OpenXml.Drawing.Text text in
                        paragraph.Descendants())
                    {
                        // Append each line to the previous lines.
                        paragraphText.Append(text.Text);
                    }

                    if (paragraphText.Length > 0)
                    {
                        // Add each paragraph to the linked list.
                        texts.AddLast(paragraphText.ToString());
                    }
                }
            }

            if (texts.Count > 0)
            {
                // Return an array of strings.
                return texts.ToArray();
            }
            else
            {
                return null;
            }
        }

    }

class Program
    {
        static void Main(string[] args)
        {
            foreach (string s in GetAllTextInSlide(@"..\..\Documents\Myppt8.pptx", 0))
                Console.WriteLine(s);
            Console.ReadLine();
        }
        // Get all the text in a slide.
        public static List GetAllTextInSlide(string presentationFile, int slideIndex)
        {
            // Create a new linked list of strings.
            List texts = new List();

            //Initialize an instances of Presentation class and load the sample PowerPoint file
            using (Presentation presentation = new Presentation(presentationFile, FileFormat.Pptx2010))
            {

                //get the slide
                ISlide slide = presentation.Slides[slideIndex];

                //Iterate through shapes to find the text
                foreach (Shape shp in slide.Shapes)
                {
                    //get the text of each placeholder
                    texts.Add(((IAutoShape)shp).TextFrame.Text);
                }

            }
            // return an array of strings.
            return texts;

        }
    }

class Program
    {
        static void Main(string[] args)
        {
            string fileName = @"..\..\Documents\Myppt7.pptx";
            foreach (string s in GetAllExternalHyperlinksInPresentation(fileName))
                Console.WriteLine(s);
        }
        // Returns all the external hyperlinks in the slides of a presentation.
        public static IEnumerable GetAllExternalHyperlinksInPresentation(string fileName)
        {
            // Declare a list of strings.
            List ret = new List();

            // Open the presentation file as read-only.
            using (PresentationDocument document = PresentationDocument.Open(fileName, false))
            {
                // Iterate through all the slide parts in the presentation part.
                foreach (SlidePart slidePart in document.PresentationPart.SlideParts)
                {
                    IEnumerable links = slidePart.Slide.Descendants();

                    // Iterate through all the links in the slide part.
                    foreach (Drawing.HyperlinkType link in links)
                    {
                        // Iterate through all the external relationships in the slide part. 
                        foreach (HyperlinkRelationship relation in slidePart.HyperlinkRelationships)
                        {
                            // If the relationship ID matches the link ID…
                            if (relation.Id.Equals(link.Id))
                            {
                                // Add the URI of the external relationship to the list of strings.
                                ret.Add(relation.Uri.AbsoluteUri);
                            }
                        }
                    }
                }
            }

            // Return the list of strings.
            return ret;
        }

    }

class Program
    {
        static void Main(string[] args)
        {
            string fileName = @"..\..\Documents\Myppt7.pptx";
            foreach (string s in GetAllExternalHyperlinksInPresentation(fileName))
                Console.WriteLine(s);
            Console.ReadLine();
        }
        // Returns all the external hyperlinks in the slides of a presentation.
        public static IEnumerable GetAllExternalHyperlinksInPresentation(string fileName)
        {
            // Declare a list of strings.
            List ret = new List();

            Presentation pres = new Presentation(fileName, FileFormat.Pptx2010);

            //Get the hyperlinks from presentation slides
            foreach (ISlide slide in pres.Slides)
            {
                foreach (IAutoShape shape in slide.Shapes)
                {
                    ret.Add(shape.TextFrame.TextRange.ClickAction.Address);
                }
            }
            return ret;
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            string fileName = @"..\..\Documents\myppt6.pptx";
            string author = "MZ";
            DeleteCommentsByAuthorInPresentation(fileName, author);
        }
        // Remove all the comments in the slides by a certain author.
        public static void DeleteCommentsByAuthorInPresentation(string fileName, string author)
        {
            if (String.IsNullOrEmpty(fileName) || String.IsNullOrEmpty(author))
                throw new ArgumentNullException("File name or author name is NULL!");

            using (PresentationDocument doc = PresentationDocument.Open(fileName, true))
            {
                // Get the specifed comment author.
                IEnumerable commentAuthors =
                    doc.PresentationPart.CommentAuthorsPart.CommentAuthorList.Elements()
                    .Where(e => e.Name.Value.Equals(author));

                // Iterate through all the matching authors.
                foreach (CommentAuthor commentAuthor in commentAuthors)
                {
                    UInt32Value authorId = commentAuthor.Id;

                    // Iterate through all the slides and get the slide parts.
                    foreach (SlidePart slide in doc.PresentationPart.SlideParts)
                    {
                        SlideCommentsPart slideCommentsPart = slide.SlideCommentsPart;
                        // Get the list of comments.
                        if (slideCommentsPart != null && slide.SlideCommentsPart.CommentList != null)
                        {
                            IEnumerable commentList =
                                slideCommentsPart.CommentList.Elements().Where(e => e.AuthorId == authorId.Value);
                            List comments = new List();
                            comments = commentList.ToList();

                            foreach (Comment comm in comments)
                            {
                                // Delete all the comments by the specified author.

                                slideCommentsPart.CommentList.RemoveChild(comm);
                            }

                            // If the commentPart has no existing comment.
                            if (slideCommentsPart.CommentList.ChildElements.Count == 0)
                                // Delete this part.
                                slide.DeletePart(slideCommentsPart);
                        }
                    }
                    // Delete the comment author from the comment authors part.
                    doc.PresentationPart.CommentAuthorsPart.CommentAuthorList.RemoveChild(commentAuthor);
                }
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            string fileName =@"..\..\Documents\myppt6.pptx";
            string author = "MZ";
            DeleteCommentsByAuthorInPresentation(fileName, author);
        }
        public static void DeleteCommentsByAuthorInPresentation(string fileName, string author)
        {
            if (String.IsNullOrEmpty(fileName) || String.IsNullOrEmpty(author))
                throw new ArgumentNullException("File name or author name is NULL!");

            //Instantiate a Presentation class
            using (Presentation pres = new Presentation(fileName, FileFormat.Pptx2010))
            {
                ICommentAuthor[] authors = pres.CommentAuthors.FindByName(author);
                ICommentAuthor thisAuthor = authors[0];
                for (int i = thisAuthor.CommentsList.Count - 1; i >= 0; i--)
                {
                    thisAuthor.CommentsList.RemoveAt(i);
                }
                //Save PPTX on disk
                pres.SaveToFile(@"..\..\Documents\result.pptx", FileFormat.Pptx2010);
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            DeleteSlide(@"..\..\Documents\Myppt5.pptx", 2);
            Console.WriteLine("Number of slides = {0}",CountSlides(@"..\..\Documents\Myppt5.pptx"));
        }
        // Get the presentation object and pass it to the next CountSlides method.
        public static int CountSlides(string presentationFile)
        {
            // Open the presentation as read-only.
            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, false))
            {
                // Pass the presentation to the next CountSlide method
                // and return the slide count.
                return CountSlides(presentationDocument);
            }
        }

        // Count the slides in the presentation.
        public static int CountSlides(PresentationDocument presentationDocument)
        {
            // Check for a null document object.
            if (presentationDocument == null)
            {
                throw new ArgumentNullException("presentationDocument");
            }

            int slidesCount = 0;

            // Get the presentation part of document.
            PresentationPart presentationPart = presentationDocument.PresentationPart;

            // Get the slide count from the SlideParts.
            if (presentationPart != null)
            {
                slidesCount = presentationPart.SlideParts.Count();
            }

            // Return the slide count to the previous method.
            return slidesCount;
        }
        //
        // Get the presentation object and pass it to the next DeleteSlide method.
        public static void DeleteSlide(string presentationFile, int slideIndex)
        {
            // Open the source document as read/write.

            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, true))
            {
                // Pass the source document and the index of the slide to be deleted to the next DeleteSlide method.
                DeleteSlide(presentationDocument, slideIndex);
            }
        }

        // Delete the specified slide from the presentation.
        public static void DeleteSlide(PresentationDocument presentationDocument, int slideIndex)
        {
            if (presentationDocument == null)
            {
                throw new ArgumentNullException("presentationDocument");
            }

            // Use the CountSlides sample to get the number of slides in the presentation.
            int slidesCount = CountSlides(presentationDocument);

            if (slideIndex < 0 || slideIndex >= slidesCount)
            {
                throw new ArgumentOutOfRangeException("slideIndex");
            }

            // Get the presentation part from the presentation document. 
            PresentationPart presentationPart = presentationDocument.PresentationPart;

            // Get the presentation from the presentation part.
            Presentation presentation = presentationPart.Presentation;

            // Get the list of slide IDs in the presentation.
            SlideIdList slideIdList = presentation.SlideIdList;

            // Get the slide ID of the specified slide
            SlideId slideId = slideIdList.ChildElements[slideIndex] as SlideId;

            // Get the relationship ID of the slide.
            string slideRelId = slideId.RelationshipId;

            // Remove the slide from the slide list.
            slideIdList.RemoveChild(slideId);

            //
            // Remove references to the slide from all custom shows.
            if (presentation.CustomShowList != null)
            {
                // Iterate through the list of custom shows.
                foreach (var customShow in presentation.CustomShowList.Elements())
                {
                    if (customShow.SlideList != null)
                    {
                        // Declare a link list of slide list entries.
                        LinkedList slideListEntries = new LinkedList();
                        foreach (SlideListEntry slideListEntry in customShow.SlideList.Elements())
                        {
                            // Find the slide reference to remove from the custom show.
                            if (slideListEntry.Id != null && slideListEntry.Id == slideRelId)
                            {
                                slideListEntries.AddLast(slideListEntry);
                            }
                        }

                        // Remove all references to the slide from the custom show.
                        foreach (SlideListEntry slideListEntry in slideListEntries)
                        {
                            customShow.SlideList.RemoveChild(slideListEntry);
                        }
                    }
                }
            }

            // Save the modified presentation.
            presentation.Save();

            // Get the slide part for the specified slide.
            SlidePart slidePart = presentationPart.GetPartById(slideRelId) as SlidePart;

            // Remove the slide part.
            presentationPart.DeletePart(slidePart);
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            DeleteSlide(@"..\..\Documents\Myppt5.pptx", 3);
        }
        public static void DeleteSlide(string presentationFile, int slideIndex)
        {
            //Get PPT document
            Presentation presentation = new Presentation();
            presentation.LoadFromFile(presentationFile);
            if (slideIndex < 0 || slideIndex >= presentation.Slides.Count)
            {
                throw new ArgumentOutOfRangeException("slideIndex");
            }
            //Remove the slide by slide index
            presentation.Slides.RemoveAt(slideIndex);

            //Save PPT document
            presentation.SaveToFile(@"..\..\Documents\result.pptx", FileFormat.Pptx2010);
        }
    }