public virtual IList <BookVersion> SearchByAuthorAndBookType(string query, BookTypeEnum bookType) { Book bookAlias = null; BookVersion bookVersionAlias = null; BookType bookTypeAlias = null; Category categoryAlias = null; Author authorAlias = null; using (var session = GetSession()) { var bookIds = QueryOver.Of(() => bookVersionAlias) .JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias, JoinType.InnerJoin) .JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias, JoinType.InnerJoin) .JoinAlias(() => bookVersionAlias.Book, () => bookAlias, JoinType.InnerJoin) .JoinAlias(() => bookVersionAlias.Authors, () => authorAlias, JoinType.InnerJoin) .Select(x => x.Id) .Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id) .AndRestrictionOn(() => authorAlias.Name).IsLike(query, MatchMode.Anywhere); var bookVersions = session.QueryOver(() => bookVersionAlias) .Fetch(x => x.Book).Eager .Fetch(x => x.Authors).Eager .WithSubquery .WhereProperty(x => x.Id) .In(bookIds) .TransformUsing(Transformers.DistinctRootEntity) .List(); return(bookVersions); } }
public virtual IList <BookVersion> FindBookVersionsByTypeWithCategories(BookTypeEnum bookType) { Book bookAlias = null; BookVersion bookVersionAlias = null; BookType bookTypeAlias = null; Category categoryAlias = null; using (var session = GetSession()) { var bookVersions = session.QueryOver(() => bookVersionAlias) .JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias) .JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias) .JoinAlias(() => bookVersionAlias.Book, () => bookAlias) .Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id) .OrderBy(() => bookVersionAlias.Title).Asc .TransformUsing(Transformers.DistinctRootEntity) .Future <BookVersion>(); session.QueryOver(() => bookVersionAlias) .JoinAlias(x => x.Book, () => bookAlias) .Where(() => bookVersionAlias.Id == bookAlias.LastVersion.Id) .Fetch(x => x.Categories).Eager .Future <BookVersion>(); return(bookVersions.ToList()); } }
public virtual IList <string> GetTermsByBookType(string query, BookTypeEnum bookType, IList <long> bookIdList, int recordCount) { using (var session = GetSession()) { Book bookAlias = null; BookVersion bookVersionAlias = null; Category categoryAlias = null; BookType bookTypeAlias = null; BookPage pageAlias = null; Term termAlias = null; var dbQuery = session.QueryOver(() => bookAlias) .JoinQueryOver(x => x.LastVersion, () => bookVersionAlias) .JoinQueryOver(x => x.Categories, () => categoryAlias) .JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias) .JoinQueryOver(x => bookVersionAlias.BookPages, () => pageAlias) .JoinQueryOver(x => pageAlias.Terms, () => termAlias) .Select(Projections.Distinct(Projections.Property(() => termAlias.Text))) .Where(x => bookTypeAlias.Type == bookType) .AndRestrictionOn(() => termAlias.Text).IsInsensitiveLike(query); if (bookIdList != null) { dbQuery.AndRestrictionOn(() => bookAlias.Id).IsInG(bookIdList); } return(dbQuery .Take(recordCount) .List <string>()); } }
public virtual IList <long> GetProjectIds(BookTypeEnum bookType, int userId, ProjectTypeEnum projectType, IList <long> projectIds, IList <int> categoryIds) { Project projectAlias = null; BookType bookTypeAlias = null; Category categoryAlias = null; Permission permissionAlias = null; UserGroup userGroupAlias = null; User userAlias = null; var query = GetSession().QueryOver <Snapshot>() .JoinAlias(x => x.Project, () => projectAlias) .JoinAlias(x => x.BookTypes, () => bookTypeAlias) .JoinAlias(() => projectAlias.Categories, () => categoryAlias, JoinType.LeftOuterJoin) .JoinAlias(() => projectAlias.Permissions, () => permissionAlias) .JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias) .JoinAlias(() => userGroupAlias.Users, () => userAlias) .And(() => bookTypeAlias.Type == bookType && userAlias.Id == userId && projectAlias.ProjectType == projectType && projectAlias.IsRemoved == false) .And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished)) .Select(Projections.Distinct(Projections.Property(() => projectAlias.Id))); if (projectIds != null && categoryIds != null) { query = query.Where(Restrictions.Or( Restrictions.InG(Projections.Property(() => projectAlias.Id), projectIds), Restrictions.InG(Projections.Property(() => categoryAlias.Id), categoryIds) )); } return(query.List <long>()); }
public virtual IList <string> GetLastTitlesByBookType(int recordCount, BookTypeEnum bookType, IList <long> bookIdList) { using (var session = GetSession()) { Book bookAlias = null; BookVersion bookVersionAlias = null; Category categoryAlias = null; BookType bookTypeAlias = null; var query = session.QueryOver(() => bookAlias) .JoinQueryOver(x => x.LastVersion, () => bookVersionAlias) .JoinQueryOver(x => x.Categories, () => categoryAlias) .JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias) .Where(x => bookTypeAlias.Type == bookType) .Select(Projections.Distinct(Projections.Property(() => bookVersionAlias.Title))); if (bookIdList != null) { query.AndRestrictionOn(() => bookAlias.Id).IsInG(bookIdList); } return(query .Take(recordCount) .List <string>()); } }
public static int?BookTypeConvert(BookTypeEnum booktype) { switch (booktype) { case BookTypeEnum.Book: return(0); case BookTypeEnum.Paper: return(1); case BookTypeEnum.Doc: return(2); case BookTypeEnum.Post: return(3); case BookTypeEnum.Magzine: return(4); case BookTypeEnum.CheetSheet: return(5); default: return(null); } }
public TBook(string name, string pathname, string rootFolder, BookTypeEnum type) : this() { Name = name; Pathname = pathname; Category = GetGroupName(rootFolder, pathname); BookType = type; }
public virtual int GetFavoriteQueriesCount(long?labelId, BookTypeEnum bookTypeEnum, QueryTypeEnum queryTypeEnum, string filterByTitle, int userId) { using (var session = GetSession()) { var query = CreateFavoriteQueriesQuery(session, labelId, bookTypeEnum, queryTypeEnum, filterByTitle, userId); return(query.RowCount()); } }
public virtual BookType FindBookTypeByType(BookTypeEnum bookTypeEnum) { using (var session = GetSession()) { return(session.QueryOver <BookType>() .Where(x => x.Type == bookTypeEnum) .SingleOrDefault()); } }
public BaseBook Create(BookTypeEnum type) { switch (type) { case BookTypeEnum.NOVEL: return(_novel); default: throw new ArgumentException("无法识别的type"); } }
private void SetSelectedBookType(BookTypeEnum type) { List <Book> books = GetSelectedBook(); foreach (Book book in books) { BookHelper.SetBookType(book, type); } JianLiLinq.Default.DB.SubmitChanges(); }
public virtual BookType GetBookType(BookTypeEnum bookType) { using (var session = GetSession()) { var result = session.QueryOver <BookType>() .Where(x => x.Type == bookType) .SingleOrDefault(); return(result); } }
public CreateSnapshotWork(ProjectRepository projectRepository, ResourceRepository resourceRepository, long projectId, int userId, IList <long> resourceVersionIds, string comment, IList <BookTypeEnum> bookTypes, BookTypeEnum defaultBookType, IFulltextStorage fulltextStorage) : base(projectRepository) { m_projectRepository = projectRepository; m_resourceRepository = resourceRepository; m_projectId = projectId; m_userId = userId; m_resourceVersionIds = resourceVersionIds; m_comment = comment; m_bookTypes = bookTypes; m_defaultBookType = defaultBookType; m_fulltextStorage = fulltextStorage; }
private void FillSubcategories(BookTypeEnum bookType, Dictionary <string, BookTypeEnum> xmlIdToBookType, List <CategoryData> categoryDataList) { foreach (var categoryData in categoryDataList) { xmlIdToBookType.Add(categoryData.XmlId, bookType); if (categoryData.SubCategories != null) { FillCategories(xmlIdToBookType, categoryData.SubCategories); } } }
public RuleResult IsValid(BookTypeEnum book, PropertyTypeEnum propType, DateTime pisDate, DeprMethodTypeEnum deprMethod, int percentage) { ErrorCode errorCode; bool isShortYr = false; IbpRuleBase rb = new bpRuleBase(); switch (deprMethod) { case DeprMethodTypeEnum.MacrsFormula: case DeprMethodTypeEnum.MacrsTable: case DeprMethodTypeEnum.MACRSIndianReservation: case DeprMethodTypeEnum.DeclBal: case DeprMethodTypeEnum.DeclBalHalfYear: case DeprMethodTypeEnum.DeclBalModHalfYear: case DeprMethodTypeEnum.DeclBalSwitch: case DeprMethodTypeEnum.DeclBalHalfYearSwitch: case DeprMethodTypeEnum.DeclBalModHalfYearSwitch: case DeprMethodTypeEnum.MacrsFormula30: case DeprMethodTypeEnum.MACRSIndianReservation30: // Build list of percentages. List <DeprPct> aList = BuildValidList(propType, pisDate, deprMethod); if (aList != null) { // iterate across all percentages, looking for the one // that matches the one we have. If found, then valid. // if no matches, then invalid. foreach (DeprPct item in aList) { if (item.Percentage == percentage) { return(RuleResult.Valid); } } } break; // Canadian BEGIN !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // The percentage must be in the range [1, 100]. case DeprMethodTypeEnum.CdnDeclBal: case DeprMethodTypeEnum.CdnDeclBalHalfYear: case DeprMethodTypeEnum.CdnDeclBalFullMonth: if ((1 <= percentage) && (percentage <= 100)) { return(RuleResult.Valid); } break; // Canadian END ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ } return(RuleResult.Invalid); }
public virtual IList <long> GetAllBookIdsByBookType(BookTypeEnum currentBookType) { using (var session = GetSession()) { Category catAlias = null; BookVersion bookVersionAlias = null; Book bookAlias = null; return(session.QueryOver <Category>(() => catAlias) .JoinQueryOver(c => c.BookType).Where(bt => bt.Type == currentBookType) .JoinQueryOver(() => catAlias.BookVersions, () => bookVersionAlias) .JoinQueryOver(() => bookVersionAlias.Book, () => bookAlias) .Where(() => bookVersionAlias.Id == bookAlias.LastVersion.Id) .Select(Projections.Property(() => bookAlias.Id)).List <long>()); } }
private BookType GetOrCreateBookTypeForEnum(BookTypeEnum bookTypeEnum) { var dbBookType = m_projectRepository.GetBookTypeByEnum(bookTypeEnum); if (dbBookType == null) { dbBookType = new BookType { Type = bookTypeEnum }; m_projectRepository.Create(dbBookType); } return(dbBookType); }
public virtual IList <FavoriteCategory> GetFavoriteCategoriesWithLabel(BookTypeEnum bookType, int userId) { Category categoryAlias = null; BookType bookTypeAlias = null; using (var session = GetSession()) { return(session.QueryOver <FavoriteCategory>() .JoinAlias(x => x.Category, () => categoryAlias) .JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias) .Where(x => x.User.Id == userId && bookTypeAlias.Type == bookType) .Fetch(x => x.FavoriteLabel).Eager .OrderBy(x => x.Title).Asc .List()); } }
public virtual IList <FavoriteQuery> GetFavoriteQueries(long?labelId, BookTypeEnum bookTypeEnum, QueryTypeEnum queryTypeEnum, string filterByTitle, int start, int count, int userId) { FavoriteLabel favoriteLabelAlias = null; using (var session = GetSession()) { var query = CreateFavoriteQueriesQuery(session, labelId, bookTypeEnum, queryTypeEnum, filterByTitle, userId); return(query.JoinAlias(x => x.FavoriteLabel, () => favoriteLabelAlias) .Fetch(x => x.FavoriteLabel).Eager .Fetch(x => x.BookType).Eager .OrderBy(x => x.Title).Asc .OrderBy(() => favoriteLabelAlias.Name).Asc .Skip(start) .Take(count) .List()); } }
public static IQueryable <Book> TypeBooks(BookTypeEnum booktype) { int?type = BookHelper.BookTypeConvert(booktype); if (type == null) { var bs = from book in JianLiLinq.Default.DB.Books where book.BookType == null select book; return(bs); } else { var bs = from book in JianLiLinq.Default.DB.Books where book.BookType == type select book; return(bs); } }
public virtual IList <string> GetLastAuthorsByBookType(int recordCount, BookTypeEnum bookType) { using (var session = GetSession()) { BookVersion bookVersionAlias = null; Author authorAlias = null; Category categoryAlias = null; BookType bookTypeAlias = null; return(session.QueryOver <Book>() .JoinQueryOver(x => x.LastVersion, () => bookVersionAlias) .JoinQueryOver(x => bookVersionAlias.Authors, () => authorAlias) .JoinQueryOver(x => bookVersionAlias.Categories, () => categoryAlias) .JoinQueryOver(x => categoryAlias.BookType, () => bookTypeAlias) .Select(Projections.Distinct(Projections.Property(() => authorAlias.Name))) .Where(x => bookTypeAlias.Type == bookType) .Take(recordCount) .List <string>()); } }
public RuleResult IsValid(BookTypeEnum book, PropertyTypeEnum propType, DateTime pisDate, DeprMethodTypeEnum deprMethod, int deprPct, YrsMosDate estLife) { ErrorCode errorCode; IbpRuleBase rb = new bpRuleBase(); rb.ValidateEstimatedLife((short)(propType), pisDate, (short)(deprMethod), (int)deprPct, (short)(estLife.Years * 100 + estLife.Months), out errorCode); switch ((RuleBase_ErrorCodeEnum)errorCode) { case RuleBase_ErrorCodeEnum.rulebase_Valid: return(RuleResult.Valid); case RuleBase_ErrorCodeEnum.rulebase_Invalid: return(RuleResult.Invalid); case RuleBase_ErrorCodeEnum.rulebase_WarnNotUsualRecoveryPd: return(RuleResult.WarnNotUsualRecoveryPd); case RuleBase_ErrorCodeEnum.rulebase_WarnNotUsualRecoveryPeriod: return(RuleResult.WarnNotUsualRecoveryPeriod); case RuleBase_ErrorCodeEnum.rulebase_WarnNotUsualUnlTransProp: return(RuleResult.WarnNotUsualUnlTransProp); case RuleBase_ErrorCodeEnum.rulebase_WarnNotOver20Years: return(RuleResult.WarnNotOver20Years); case RuleBase_ErrorCodeEnum.rulebase_WarnAANotOver20Years: return(RuleResult.WarnAANotOver20Years); case RuleBase_ErrorCodeEnum.rulebase_WarnOnlyNYLZAllowForRMF100EST0500: return(RuleResult.WarnOnlyNYLZAllowForRMF100EST0500); case RuleBase_ErrorCodeEnum.rulebase_RuleBaseFailure: return(RuleResult.RuleBaseFailure); } // section 179 does not apply. return(RuleResult.Invalid); }
public virtual IList <BookVersion> SearchByTitleAndBookType(string text, BookTypeEnum bookType) { Book bookAlias = null; BookVersion bookVersionAlias = null; BookType bookTypeAlias = null; Category categoryAlias = null; using (var session = GetSession()) { var bookVersions = session.QueryOver(() => bookVersionAlias) .JoinAlias(() => bookVersionAlias.Categories, () => categoryAlias, JoinType.InnerJoin) .JoinAlias(() => categoryAlias.BookType, () => bookTypeAlias, JoinType.InnerJoin) .JoinAlias(() => bookVersionAlias.Book, () => bookAlias, JoinType.InnerJoin) .Where(() => bookTypeAlias.Type == bookType && bookVersionAlias.Id == bookAlias.LastVersion.Id) .AndRestrictionOn(() => bookVersionAlias.Title).IsLike(text, MatchMode.Anywhere) .Fetch(x => x.Authors).Eager .TransformUsing(Transformers.DistinctRootEntity) .List <BookVersion>(); return(bookVersions); } }
public virtual IList <FavoriteProject> GetFavoriteBooksWithLabel(BookTypeEnum bookType, ProjectTypeEnum?projectType, int userId) { FavoriteLabel favoriteLabelAlias = null; Project projectAlias = null; Snapshot latestSnapshotAlias = null; BookType bookTypeAlias = null; var query = GetSession().QueryOver <FavoriteProject>() .JoinAlias(x => x.FavoriteLabel, () => favoriteLabelAlias) .JoinAlias(x => x.Project, () => projectAlias) .JoinAlias(() => projectAlias.LatestPublishedSnapshot, () => latestSnapshotAlias) .JoinAlias(() => latestSnapshotAlias.BookTypes, () => bookTypeAlias) .Where(() => favoriteLabelAlias.User.Id == userId && bookTypeAlias.Type == bookType && projectAlias.IsRemoved == false); if (projectType != null) { query.And(() => projectAlias.ProjectType == projectType.Value); } return(query.Fetch(SelectMode.Fetch, x => x.FavoriteLabel) .OrderBy(x => x.Title).Asc .List()); }
public virtual IList <MetadataResource> GetMetadataByBookTypeWithCategories(BookTypeEnum bookTypeEnum, int userId, ProjectTypeEnum projectType, int start, int count) { Resource resourceAlias = null; Snapshot snapshotAlias = null; BookType bookTypeAlias = null; Permission permissionAlias = null; UserGroup userGroupAlias = null; User userAlias = null; var resultList = GetSession().QueryOver <MetadataResource>() .JoinAlias(x => x.Resource, () => resourceAlias) .Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved) .WithSubquery.WhereProperty(() => resourceAlias.Project.Id).In(QueryOver.Of <Project>() .Where(x => x.ProjectType == projectType && x.IsRemoved == false) .JoinAlias(x => x.LatestPublishedSnapshot, () => snapshotAlias) .JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias) .Where(() => bookTypeAlias.Type == bookTypeEnum) .JoinAlias(x => x.Permissions, () => permissionAlias) .JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias) .JoinAlias(() => userGroupAlias.Users, () => userAlias) .Where(() => userAlias.Id == userId) .And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished)) .Select(x => x.Id)) .OrderBy(x => x.Title).Asc .Skip(start) .Take(count) .List(); GetSession().QueryOver <Project>() .WhereRestrictionOn(x => x.Id).IsInG(resultList.Select(x => x.Resource.Project.Id)) .Fetch(SelectMode.Fetch, x => x.Categories) .List(); return(resultList); }
public virtual IList <Category> FindCategoriesByBookType(BookTypeEnum type) { using (var session = GetSession()) { Category categoryAlias = null; BookType bookTypeAlias = null; var rootCategory = session.QueryOver(() => categoryAlias) .JoinAlias(x => x.BookType, () => bookTypeAlias) .Where(() => bookTypeAlias.Type == type && categoryAlias.ParentCategory == null) .SingleOrDefault <Category>(); if (rootCategory == null) { return(new List <Category>()); } return(session.QueryOver <Category>() .WhereRestrictionOn(x => x.Path) .IsLike(rootCategory.Path, MatchMode.Start) .OrderBy(x => x.Description).Asc .List <Category>()); } }
public virtual IList <Category> FindCategoriesByBookTypeii(BookTypeEnum type) { using (var session = GetSession()) { Category categoryAlias = null; BookType bookTypeAlias = null; var rootCategory = session.QueryOver(() => categoryAlias) .JoinAlias(x => x.BookType, () => bookTypeAlias) .Where(() => bookTypeAlias.Type == type && categoryAlias.ParentCategory == null) .SingleOrDefault <Category>(); if (rootCategory == null) { return(new List <Category>()); } var resultCategories = new List <Category>(); IList <Category> childCategories = new List <Category> { rootCategory }; while (childCategories != null && childCategories.Count() != 0) { resultCategories.AddRange(childCategories); IList <int> parentCategoriesIds = childCategories.Select(childCategory => childCategory.Id).ToList(); var ids = parentCategoriesIds; childCategories = session.QueryOver(() => categoryAlias) .Where(() => categoryAlias.ParentCategory.Id.IsIn(ids.ToArray())) .List <Category>(); } return(resultCategories); } }
public virtual BookType GetBookTypeByEnum(BookTypeEnum bookTypeEnum) { return(GetSession().QueryOver <BookType>() .Where(x => x.Type == bookTypeEnum) .SingleOrDefault()); }
public virtual ListWithTotalCountResult <FavoriteQuery> GetFavoriteQueries(long?labelId, BookTypeEnum bookTypeEnum, QueryTypeEnum queryTypeEnum, string filterByTitle, int start, int count, int userId) { FavoriteQuery favoriteQueryAlias = null; FavoriteLabel favoriteLabelAlias = null; BookType bookTypeAlias = null; var query = GetSession().QueryOver(() => favoriteQueryAlias) .JoinAlias(() => favoriteQueryAlias.FavoriteLabel, () => favoriteLabelAlias) .JoinAlias(() => favoriteQueryAlias.BookType, () => bookTypeAlias) .Where(() => bookTypeAlias.Type == bookTypeEnum && favoriteQueryAlias.QueryType == queryTypeEnum && favoriteLabelAlias.User.Id == userId) .Fetch(SelectMode.Fetch, x => x.FavoriteLabel) .Fetch(SelectMode.Fetch, x => x.BookType) .OrderBy(x => x.Title).Asc .OrderBy(() => favoriteLabelAlias.Name).Asc; if (labelId != null) { query.And(() => favoriteQueryAlias.FavoriteLabel.Id == labelId.Value); } if (!string.IsNullOrEmpty(filterByTitle)) { filterByTitle = EscapeQuery(filterByTitle); query.AndRestrictionOn(() => favoriteQueryAlias.Title).IsLike(filterByTitle, MatchMode.Anywhere); } var list = query.Skip(start) .Take(count) .Future(); var totalCount = query.ToRowCountQuery() .FutureValue <int>(); return(new ListWithTotalCountResult <FavoriteQuery> { List = list.ToList(), Count = totalCount.Value, }); }
//Add Book private void btnAddBook_Click(object sender, EventArgs e) { string bookType = cmbBookType.Text; string title = txtTitle.Text; double price = double.Parse(txtPrice.Text); string publisher = txtPublisher.Text; int yearPublished = int.Parse(txtYearPublished.Text); int isbn = int.Parse(txtISBN.Text); int numberOfPages = int.Parse(txtNumberOfPages.Text); if (bookType == "E-Book") { int fileSize = int.Parse(txtFileSize.Text); EBook newEbook = new EBook(title, price, publisher, yearPublished, isbn, numberOfPages, fileSize); if (AddNewBook(newEbook)) { MessageBox.Show("Successful Insertion"); } else { MessageBox.Show("Fail Insertion"); } } else if (bookType == "Textbook") { BookTypeEnum textBookType = (BookTypeEnum)cmbTextbookType.SelectedItem; Textbook newTextbook = new Textbook(title, price, publisher, yearPublished, isbn, numberOfPages, textBookType); if (AddNewBook(newTextbook)) { MessageBox.Show("Successful Insertion"); } else { MessageBox.Show("Fail Insertion"); } } txtTitle.Clear(); txtPrice.Clear(); txtPublisher.Clear(); txtYearPublished.Clear(); txtISBN.Clear(); txtNumberOfPages.Clear(); txtFileSize.Clear(); #region Manual Data Input Test //Test - input sample date manually first //EBook eb = new EBook(title, price, publisher, yearPublished, isbn, numberOfPages, fileSize); //eb.Title = "Book1"; //eb.Price = 6.50; //eb.Publisher = "Thien"; //eb.YearPublished = 1999; //eb.ISBN = 1234; //eb.NumberOfPages = 50; //eb.FileSize = 1000; //MessageBox.Show(eb.ToString()); #endregion }