Fundamentals of Computer Programming with C#

(The Bulgarian C# Programming Book)

by Svetlin Nakov & Co.

[Link]

ISBN: 978-954-400-773-7
ISBN-13: 978-954-400-773-7 (9789544007737)
ISBN-10: 954-400-773-3 (9544007733)
Pages: 1132
Language: English
Published: Sofia, 2013

Tags: book; free book; ebook; e-book; programming; computer programming; programming concepts; programming principles; tutorial;
C#; data structures; algorithms; Intro C#; C# book; book C#; CSharp; CSharp book; programming book; book programming; textbook;
learn C#; study C#; learn programming; study programming; how to program; programmer; practical programming guide; software
engineer; software engineering; computer programming; software developer; software technologies; programming techniques; logi cal
thinking; algorithmic thinking; developer; software development; programming knowledge; programming skills; programming language;
basics of programming; presentations; presentation slides; coding; coder; source code; compiler; development tools; code decompiler;
JustDecompile; debugging code; debugger; Visual Studio; IDE; development environment; bug fixing; class library; API; C#; .NET; .NET
Framework; types; variables; operators; expressions; statements; value types; reference types; type conversion; console; console input;
console output; console application; conditional statements; if; if-else; switch-case; loops; whole; do-while; for loops; foreach; nested
loops; arrays; matrices; multidimensional arrays; numeral systems; binary numbers; decimal numbers; hexadecimal numbers;
representations of numbers; methods; method invocation; parameters; recursion; iteration; recursive algorithms; classes; objects; fields;
constructors; properties; static fields; static methods; static constructor; static members; namespaces; exceptions; exception handling;
stack trace; catch exception; throw exception; try-catch; try-finally; using statement; strings; text processing; StringBuilder; escaping;
[Link]; regular expressions; string formatting; OOP; object-oriented programming; access modifiers; public; private; protected;
internal; this keyword; const fields; readonly fields; default constructor; implicit constructor; overloading; method overloading; constructor
overloading; automatic properties; read-only properties; constants; enumerations; inner classes; nested classes; generics; generic types;
generic methods; text files; streams; files; StreamReader; StreamWriter; data structures; ADT; abstract data structure; linear data
structures; list; linked list; static list; doubly-linked list; array list; stack; queue; deque; trees; graphs; binary tree; binary search tree;
balanced tree; balanced search tree; B-tree; red-black tree; tree traversal; ordered balanced search tree; graph representation; list of
edges; list of successors; adjacency matrix; depth-first search; DFS; breadth-first search; BFS; dictionary; hash table; associative array;
hash function; collision resolution; set; multi set; bag; multi bag; multi dictionary; algorithm complexity; asymptotic notation; time
complexity; memory complexity; execution time; performance; collection classes; .NET collections; Wintellect Power Collections; OOP;
principles; abstraction; encapsulation; polymorphism; abstract class; interface; operation contract; virtual method; method overriding;
cohesion; strong cohesion; coupling; loose coupling; spaghetti code; object-oriented modeling; UML; use-case diagram; sequence diagram;
statechart diagram; activity diagram; design patterns; singleton; factory method; code quality; high-quality code; code conventions; naming
identifiers; variable names; method names; naming classes; code formatting; high-quality classes; high-quality methods; variable scope;
variable span; variable lifetime; control-flow statements; defensive programming; assertions; code documentation; documentation; self-
documenting code; code refactoring; lambda expressions; LINQ; extension methods; anonymous types; LINQ queries; data filtering; data
searching; data sorting; data grouping; problem solving; problem solving methodology; problems and solutions; generating ideas; task
decomposition; algorithm efficiency; writing code; code testing; border cases testing; borderline cases; performance testing; regression
testing; exercises; problems; solutions; programming guidelines; programming problems; programming exercises; good programmer;
efficient programmer; pragmatic programmer; Nakov; Svetlin Nakov; Telerik; Telerik Academy; Telerik Software Academy; Bulgaria;
Bulgarian book; BG book; Bulgarian C# book; Kolev; Vesselin Kolev; Dilyan Dimitrov; Hristo Germanov; Iliyan Murdanliev; Mihail Stoynov;
Mihail Valkov; Mira Bivas; Nikolay Kostov; Nikolay Nedyalkov; Nikolay Vassilev; Pavel Donchev; Pavlina Hadjieva; Radoslav Ivanov;
Radoslav Kirilov; Radoslav Todorov; Stanislav Zlatinov; Stefan Staev; Svetlin Nakov; Teodor Bozhikov; Teodor Stoev; Tsvyatko Konov;
Vesselin Georgiev; Yordan Pavlov; Yosif Yosifov, 9789544007737, 9544007733, ISBN 978-954-400-773-7, ISBN 954-400-773-3

Book Front Cover

 Contents

Contents .............................................................................................. 2
Detailed Table of Contents .................................................................. 9
Preface .............................................................................................. 17
Chapter 1. Introduction to Programming........................................... 73
Chapter 2. Primitive Types and Variables ........................................ 115
Chapter 3. Operators and Expressions ............................................. 143
Chapter 4. Console Input and Output .............................................. 169
Chapter 5. Conditional Statements .................................................. 199
Chapter 6. Loops ............................................................................. 215
Chapter 7. Arrays ............................................................................ 239
Chapter 8. Numeral Systems ........................................................... 269
Chapter 9. Methods ......................................................................... 297
Chapter 10. Recursion ..................................................................... 355
Chapter 11. Creating and Using Objects .......................................... 389
Chapter 12. Exception Handling ...................................................... 419
Chapter 13. Strings and Text Processing ......................................... 461
Chapter 14. Defining Classes ........................................................... 503
Chapter 15. Text Files...................................................................... 619
Chapter 16. Linear Data Structures ................................................. 645
Chapter 17. Trees and Graphs ......................................................... 685
Chapter 18. Dictionaries, Hash-Tables and Sets .............................. 731
Chapter 19. Data Structures and Algorithm Complexity .................. 773
Chapter 20. Object-Oriented Programming Principles ..................... 811
Chapter 21. High-Quality Programming Code .................................. 857
Chapter 22. Lambda Expressions and LINQ ..................................... 919
Chapter 23. Methodology of Problem Solving .................................. 939
Chapter 24. Sample Programming Exam – Topic #1 ........................ 989
Chapter 25. Sample Programming Exam – Topic #2 ...................... 1045
Chapter 26. Sample Programming Exam – Topic #3 ...................... 1075
Conclusion ..................................................................................... 1123
 FUNDAMENTALS OF
COMPUTER PROGRAMMING
WITH C#

(The Bulgarian C# Programming Book)

Svetlin Nakov & Co.

Dilyan Dimitrov Radoslav Kirilov

Hristo Germanov Radoslav Todorov
Iliyan Murdanliev Stanislav Zlatinov
Mihail Stoynov Stefan Staev
Mihail Valkov Svetlin Nakov
Mira Bivas Teodor Bozhikov
Nikolay Kostov Teodor Stoev
Nikolay Nedyalkov Tsvyatko Konov
Nikolay Vasilev Vesselin Georgiev
Pavel Donchev Veselin Kolev
Pavlina Hadjieva Yordan Pavlov
Radoslav Ivanov Yosif Yosifov

Telerik Software Academy

Sofia, 2013
FUNDAMENTALS OF COMPUTER
PROGRAMMING WITH C#
(The Bulgarian C# Programming Book)

© Svetlin Nakov & Co., 2013

© Telerik Software Academy, 2013

The book is distributed freely under the following license conditions:

1. Book readers (users) may:
- distribute free of charge unaltered copies of the book in electronic or
paper format;
- use portions of the book and the source code examples or their
modifications, for all intents and purposes, including educational and
commercial projects, provided they clearly specify the original source,
the original author(s) of the corresponding text or source code, this
license and the website [Link];
- distribute free of charge portions of the book or modified copies of it
(including translating the book into other languages or adapting it to
other programming languages and platforms), but only by explicitly
mentioning the original source and the authors of the corresponding
text, source code or other material, this license and the official website
of the project: [Link].
2. Book readers (users) may NOT:
- distribute for profit the book or portions of it, with the exception of the
source code;
- remove this license from the book when modifying it for own needs.
All trademarks referenced in this book are the property of their respective
owners.

Official Web Site:

[Link]

ISBN 978-954-400-773-7
Telerik Software Academy
[Link]
Telerik End-To-End Solution
[Link]
 [Link]

Bulgarian Association of Software Developers (BASD) is a

non-profit organization that supports the Bulgarian software
developers through educational and other initiatives.

BASD works to promote exchange of experience between the

developers and improvement of their knowledge and skills in
the area of software development and software technologies.

The Association organizes conferences, seminars and training

courses for software engineers and other professionals
involved in the software industry.
 DevReach Conference
[Link]
 Detailed Table of Contents

Contents .............................................................................................. 2
Detailed Table of Contents .................................................................. 9
Preface .............................................................................................. 17
About the Book ............................................................................................. 17
C# and .NET Framework ................................................................................ 21
How То Read This Book? ................................................................................ 26
Why Are Data Structures and Algorithms Emphasized? ...................................... 29
Do You Really Want to Become a Programmer? ................................................. 30
A Look at the Book’s Contents ........................................................................ 33
History: How Did This Book Come to Be? ......................................................... 42
Authors and Contributors ............................................................................... 44
The Book Is Free of Charge! ........................................................................... 57
Reviews ....................................................................................................... 57
Sponsor ....................................................................................................... 67
License ........................................................................................................ 68
Resources Coming with the Book..................................................................... 69
Chapter 1. Introduction to Programming........................................... 73
In This Chapter ............................................................................................. 73
What Does It Mean "To Program"? .................................................................. 73
Stages in Software Development ..................................................................... 75
Our First C# Program .................................................................................... 79
The C# Language and the .NET Platform .......................................................... 83
Visual Studio IDE .......................................................................................... 97
Alternatives to Visual Studio .......................................................................... 108
Decompiling Code ........................................................................................ 108
C# in Linux, iOS and Android ......................................................................... 111
Other .NET Languages .................................................................................. 111
Exercises..................................................................................................... 112
Solutions and Guidelines ............................................................................... 112
Chapter 2. Primitive Types and Variables ........................................ 115
In This Chapter ............................................................................................ 115
What Is a Variable? ...................................................................................... 115
Data Types .................................................................................................. 115
Variables ..................................................................................................... 127
Value and Reference Types ............................................................................ 132
10 Fundamentals of Computer Programming with C#

Literals ....................................................................................................... 135

Exercises..................................................................................................... 139
Solutions and Guidelines ............................................................................... 140
Chapter 3. Operators and Expressions ............................................. 143
In This Chapter ............................................................................................ 143
Operators .................................................................................................... 143
Type Conversion and Casting ......................................................................... 156
Expressions ................................................................................................. 162
Exercises..................................................................................................... 164
Solutions and Guidelines ............................................................................... 165
Chapter 4. Console Input and Output .............................................. 169
In This Chapter ............................................................................................ 169
What Is the Console? .................................................................................... 169
Standard Input-Output ................................................................................. 173
Printing to the Console .................................................................................. 173
Console Input .............................................................................................. 187
Console Input and Output – Examples ............................................................ 194
Exercises..................................................................................................... 196
Solutions and Guidelines ............................................................................... 197
Chapter 5. Conditional Statements .................................................. 199
In This Chapter ............................................................................................ 199
Comparison Operators and Boolean Expressions .............................................. 199
Conditional Statements "if" and "if-else" ......................................................... 204
Conditional Statement "switch-case"............................................................... 210
Exercises..................................................................................................... 212
Solutions and Guidelines ............................................................................... 213
Chapter 6. Loops ............................................................................. 215
In This Chapter ............................................................................................ 215
What Is a "Loop"? ........................................................................................ 215
While Loops ................................................................................................. 215
Do-While Loops ............................................................................................ 220
For Loops .................................................................................................... 225
Foreach Loops ............................................................................................. 229
Nested Loops ............................................................................................... 230
Exercises..................................................................................................... 235
Solutions and Guidelines ............................................................................... 237
Chapter 7. Arrays ............................................................................ 239
In This Chapter ............................................................................................ 239
What Is an "Array"? ...................................................................................... 239
Declaration and Allocation of Memory for Arrays .............................................. 239
Access to the Elements of an Array ................................................................. 242
 Detailed Table of Contents 11

Reading an Array from the Console ................................................................ 245

Printing an Array to the Console ..................................................................... 247
Iteration through Elements of an Array ........................................................... 248
Multidimensional Arrays ................................................................................ 250
Arrays of Arrays ........................................................................................... 257
Exercises..................................................................................................... 261
Solutions and Guidelines ............................................................................... 263
Chapter 8. Numeral Systems ........................................................... 269
In This Chapter ............................................................................................ 269
History in a Nutshell ..................................................................................... 269
Numeral Systems ......................................................................................... 270
Representation of Numbers ........................................................................... 280
Exercises..................................................................................................... 293
Solutions and Guidelines ............................................................................... 294
Chapter 9. Methods ......................................................................... 297
In This Chapter ............................................................................................ 297
Subroutines in Programming.......................................................................... 297
What Is a "Method"? ..................................................................................... 297
Why to Use Methods? ................................................................................... 298
How to Declare, Implement and Invoke a Method? ........................................... 299
Declaring Our Own Method ............................................................................ 299
Implementation (Creation) of Own Method ...................................................... 304
Invoking a Method........................................................................................ 305
Parameters in Methods ................................................................................. 307
Returning a Result from a Method .................................................................. 332
Best Practices when Using Methods ................................................................ 349
Exercises..................................................................................................... 351
Solutions and Guidelines ............................................................................... 352
Chapter 10. Recursion ..................................................................... 355
In This Chapter ............................................................................................ 355
What Is Recursion? ....................................................................................... 355
Example of Recursion ................................................................................... 355
Direct and Indirect Recursion ......................................................................... 356
Bottom of Recursion ..................................................................................... 356
Creating Recursive Methods ........................................................................... 356
Recursive Calculation of Factorial ................................................................... 357
Recursion or Iteration?.................................................................................. 359
Simulation of N Nested Loops ........................................................................ 360
Which is Better: Recursion or Iteration? .......................................................... 366
Using Recursion – Conclusions ....................................................................... 382
Exercises..................................................................................................... 382
Solutions and Guidelines ............................................................................... 384
12 Fundamentals of Computer Programming with C#

Chapter 11. Creating and Using Objects .......................................... 389

In This Chapter ............................................................................................ 389
Classes and Objects...................................................................................... 389
Classes in C#............................................................................................... 391
Creating and Using Objects ........................................................................... 394
Namespaces ................................................................................................ 409
Exercises..................................................................................................... 414
Solutions and Guidelines ............................................................................... 416
Chapter 12. Exception Handling ...................................................... 419
In This Chapter ............................................................................................ 419
What Is an Exception? .................................................................................. 419
Exceptions Hierarchy .................................................................................... 428
Throwing and Catching Exceptions ................................................................. 430
The try-finally Construct................................................................................ 436
IDisposable and the "using" Statement ........................................................... 441
Advantages of Using Exceptions ..................................................................... 443
Best Practices when Using Exceptions ............................................................. 449
Exercises..................................................................................................... 457
Solutions and Guidelines ............................................................................... 458
Chapter 13. Strings and Text Processing ......................................... 461
In This Chapter ............................................................................................ 461
Strings ........................................................................................................ 461
Strings Operations........................................................................................ 466
Constructing Strings: the StringBuilder Class ................................................... 484
String Formatting ......................................................................................... 492
Exercises..................................................................................................... 495
Solutions and Guidelines ............................................................................... 500
Chapter 14. Defining Classes ........................................................... 503
In This Chapter ............................................................................................ 503
Custom Classes............................................................................................ 503
Usage of Class and Objects............................................................................ 506
Organizing Classes in Files and Namespaces .................................................... 509
Modifiers and Access Levels (Visibility) ............................................................ 512
Declaring Classes ......................................................................................... 513
The Reserved Word "this" .............................................................................. 515
Fields.......................................................................................................... 516
Methods ...................................................................................................... 522
Accessing Non-Static Data of the Class ........................................................... 523
Hiding Fields with Local Variables ................................................................... 526
Visibility of Fields and Methods....................................................................... 528
Constructors ................................................................................................ 535
Properties ................................................................................................... 553
 Detailed Table of Contents 13

Static Classes and Static Members ................................................................. 563

Structures ................................................................................................... 584
Enumerations .............................................................................................. 588
Inner Classes (Nested Classes) ...................................................................... 594
Generics ..................................................................................................... 598
Exercises..................................................................................................... 614
Solutions and Guidelines ............................................................................... 617
Chapter 15. Text Files...................................................................... 619
In This Chapter ............................................................................................ 619
Streams ...................................................................................................... 619
Reading from a Text File ............................................................................... 624
Writing to a Text File .................................................................................... 632
Input / Output Exception Handling ................................................................. 634
Text Files – More Examples ........................................................................... 635
Exercises..................................................................................................... 640
Solutions and Guidelines ............................................................................... 642
Chapter 16. Linear Data Structures ................................................. 645
In This Chapter ............................................................................................ 645
Abstract Data Structures ............................................................................... 645
List Data Structures ...................................................................................... 646
Exercises..................................................................................................... 680
Solutions and Guidelines ............................................................................... 682
Chapter 17. Trees and Graphs ......................................................... 685
In This Chapter ............................................................................................ 685
Tree Data Structures .................................................................................... 685
Trees .......................................................................................................... 685
Graphs ........................................................................................................ 718
Exercises..................................................................................................... 726
Solutions and Guidelines ............................................................................... 727
Chapter 18. Dictionaries, Hash-Tables and Sets .............................. 731
In This Chapter ............................................................................................ 731
Dictionary Data Structure .............................................................................. 731
Hash-Tables ................................................................................................ 739
The "Set" Data Structure ............................................................................... 764
Exercises..................................................................................................... 769
Solutions and Guidelines ............................................................................... 771
Chapter 19. Data Structures and Algorithm Complexity .................. 773
In This Chapter ............................................................................................ 773
Why Are Data Structures So Important?.......................................................... 773
Algorithm Complexity ................................................................................... 774
Comparison between Basic Data Structures ..................................................... 783
14 Fundamentals of Computer Programming with C#

When to Use a Particular Data Structure? ........................................................ 783

Choosing a Data Structure – Examples ........................................................... 790
External Libraries with .NET Collections ........................................................... 805
Exercises..................................................................................................... 807
Solutions and Guidelines ............................................................................... 808
Chapter 20. Object-Oriented Programming Principles ..................... 811
In This Chapter ............................................................................................ 811
Let’s Review: Classes and Objects .................................................................. 811
Object-Oriented Programming (OOP) .............................................................. 811
Fundamental Principles of OOP ....................................................................... 812
Inheritance .................................................................................................. 813
Abstraction .................................................................................................. 828
Encapsulation .............................................................................................. 832
Polymorphism .............................................................................................. 834
Cohesion and Coupling .................................................................................. 840
Object-Oriented Modeling (OOM) .................................................................... 846
UML Notation ............................................................................................... 848
Design Patterns............................................................................................ 851
Exercises..................................................................................................... 855
Solutions and Guidelines ............................................................................... 856
Chapter 21. High-Quality Programming Code .................................. 857
In This Chapter ............................................................................................ 857
Why Is Code Quality Important? .................................................................... 857
What Does Quality Programming Code Mean? .................................................. 858
Why Should We Write Quality Code? ............................................................... 858
Identifier Naming ......................................................................................... 861
Code Formatting .......................................................................................... 870
High-Quality Classes ..................................................................................... 878
High-Quality Methods ................................................................................... 882
Proper Use of Variables ................................................................................. 887
Proper Use of Expressions ............................................................................. 894
Use of Constants .......................................................................................... 895
Proper Use of Control Flow Statements ........................................................... 898
Defensive Programming ................................................................................ 902
Code Documentation .................................................................................... 904
Code Refactoring .......................................................................................... 908
Unit Testing ................................................................................................. 909
Additional Resources..................................................................................... 916
Exercises..................................................................................................... 916
Solutions and Guidelines ............................................................................... 917
Chapter 22. Lambda Expressions and LINQ ..................................... 919
In This Chapter ............................................................................................ 919
 Detailed Table of Contents 15

Extension Methods ....................................................................................... 919

Anonymous Types ........................................................................................ 922
Lambda Expressions ..................................................................................... 924
LINQ Queries ............................................................................................... 928
Nested LINQ Queries .................................................................................... 934
LINQ Performance ........................................................................................ 934
Exercises..................................................................................................... 937
Solutions and Guidelines ............................................................................... 937
Chapter 23. Methodology of Problem Solving .................................. 939
In This Chapter ............................................................................................ 939
Basic Principles of Solving Computer Programming Problems ............................. 939
Use Pen and Paper ....................................................................................... 940
Generate Ideas and Give Them a Try! ............................................................. 941
Decompose the Task into Smaller Subtasks ..................................................... 942
Verify Your Ideas! ........................................................................................ 945
If a Problem Occurs, Invent a New Idea! ......................................................... 947
Choose Appropriate Data Structures! .............................................................. 950
Think about the Efficiency! ............................................................................ 954
Implement Your Algorithm! ........................................................................... 957
Write the Code Step by Step! ........................................................................ 958
Test Your Solution! ....................................................................................... 971
General Conclusions ..................................................................................... 983
Exercises..................................................................................................... 984
Solutions and Guidelines ............................................................................... 987
Chapter 24. Sample Programming Exam – Topic #1 ........................ 989
In This Chapter ............................................................................................ 989
Problem 1: Extract Text from HTML Document ................................................. 989
Problem 2: Escape from Labyrinth ................................................................ 1016
Problem 3: Store for Car Parts ..................................................................... 1030
Exercises................................................................................................... 1042
Solutions and Guidelines ............................................................................. 1044
Chapter 25. Sample Programming Exam – Topic #2 ...................... 1045
In This Chapter .......................................................................................... 1045
Problem 1: Counting the Uppercase / Lowercase Words in a Text ..................... 1045
Problem 2: A Matrix of Prime Numbers ......................................................... 1058
Problem 3: Evaluate an Arithmetic Expression ............................................... 1064
Exercises................................................................................................... 1073
Solutions and Guidelines ............................................................................. 1073
Chapter 26. Sample Programming Exam – Topic #3 ...................... 1075
In This Chapter .......................................................................................... 1075
Problem 1: Spiral Matrix ............................................................................. 1075
Problem 2: Counting Words in a Text File ...................................................... 1082
16 Fundamentals of Computer Programming with C#

Problem 3: School ...................................................................................... 1103

Exercises................................................................................................... 1121
Solutions and Guidelines ............................................................................. 1122
Conclusion ..................................................................................... 1123
Did You Solve All Problems? ........................................................................ 1123
Have You Encountered Difficulties with the Exercises? ..................................... 1123
How Do You Proceed After Reading the Book? ................................................ 1124
Free Courses at Telerik Software Academy .................................................... 1125
Good Luck to Everyone! .............................................................................. 1130
 Preface

If you want to take up programming seriously, you’ve come across the

right book. For real! This is the book with which you can make your first
steps in programming. It will give a flying start to your long journey into
learning modern programming languages and software development
technologies. This book teaches the fundamental principles and concepts
of programming, which have not changed significantly in the past 15 years.
Do not hesitate to read this book even if C# is not the language you would
like to pursue. Whatever language you move on to, the knowledge we will
give you here will stick, because this book will teach you to think like
programmers. We will show you and teach you how to write programs for
solving practical algorithmic problems, form the skills in you to come up
with (and implement) algorithms, and use various data structures.
As improbable as it might seem to you, the basic principles of writing
computer programs have not changed all that much in the past 15 years.
Programming languages change, technologies get modernized, integrated
development environments get more and more advanced but the
fundamental principles of programming remain the same. When
beginners learn to think algorithmically, and then learn to divide a problem
instinctively into a series of steps to solve it, as well as when they learn to
select the appropriate data structures and write high-quality programming
code that is when they become programmers. Once you acquire these skills,
you can easily learn new languages and various technologies – like Web
programming, HTML5 and JavaScript, mobile development, databases and
SQL, XML, REST, [Link], Java EE, Python, Ruby and hundreds more.

About the Book

This book is designed specifically to teach you to think like a programmer and
the C# language is just a tool that can be replaced by any other modern
programming languages, such as Java, C++, PHP or Python. This is a book
on programming, not a book on C#!

Please Excuse Us for the Bugs in the Translation!

This book was originally written in Bulgarian language by a large team of
volunteer software engineers and later translated into English. None of the
authors, translators, editors and the other contributors is a native English
speaker so you might find many mistakes and imprecise translation. Please,
excuse us! Over 70 people have participated in this project (mostly
Bulgarians): authors, editors, translators, correctors, bug submitters, etc. and
 Thank You for previewing this eBook
You can read the full version of this eBook in different formats:

 HTML (Free /Available to everyone)

 PDF / TXT (Available to V.I.P. members. Free Standard members can

access up to 5 PDF/TXT eBooks per month each month)

 Epub & Mobipocket (Exclusive to V.I.P. members)

To download this full book, simply select the format you desire below