Practical Mono

by Mamone, Mark

• ISBN13: 9781590595480
• ISBN10: 1590595483
• Format: Hardcover
• Copyright: 2005-12-12
• Publisher: Springer-Verlag New York Inc

Summary

The Mono project is an open source implementation of the groundbreaking Microsoft .NET platform, backed by Novell and supported by thousands of contributors from around the world. Practical Mono offers readers a detailed examination of Mono and its many facets, such as building GUI-based applications with Gtk#, database interaction ADO.NET, and creating powerful applications with XML and Web Services. By embracing this implementation, users are able to take advantage of the powerful development paradigm, building Internet-enabled cross-platform applications based on freely available, open source technologies. It includes a briefing on the C# language, so even novice .NET programmers stand to gain plenty from this practical guide.

Table of Contents

About the Author	xv
About the Technical Reviewer	xvii
Preface	xix
Introducing .NET and Mono	1	(20)
Microsoft Introduces .NET	1	(1)
What Is .NET?	2	(5)
The .NET Framework	2	(1)
.NET As an Open Industry Standard	3	(2)
Technologies	5	(1)
.NET Tools	6	(1)
The History of Mono	7	(1)
What Is Mono?	7	(3)
Core Mono	7	(1)
Additional Mono Components	8	(2)
How to Get Involved with Mono	10	(1)
How to Obtain Mono	11	(2)
How to Install Mono on Linux	13	(3)
How to Install Mono on Windows	16	(3)
The Book's Project	19	(1)
Mono Support of .NET 2.0	19	(1)
Summary	20	(1)
Introducing Development Tools and MonoDevelop	21	(20)
What IDEs Are Available?	21	(2)
Introducing MonoDevelop	23	(4)
The History of MonoDevelop	23	(1)
Downloading MonoDevelop	23	(2)
Installing MonoDevelop on Linux	25	(2)
Introducing the MonoDevelop Layout	27	(2)
The Menu	28	(1)
The Toolbar	28	(1)
The Main Source Window	28	(1)
The Solution Explorer	28	(1)
Creating a Project	29	(5)
What's a Solution Used For?	30	(1)
Adding Project Files	31	(1)
Configuring Your Target Output	32	(1)
Building Your Target	33	(1)
Testing Your Target	33	(1)
Compiling Code	34	(3)
Executing Code	36	(1)
Examining the Execution Model	36	(1)
Debugging Your Projects	37	(1)
Using the Class Viewer	38	(1)
Using Other Tools	39	(1)
C# Compiler	39	(1)
Mono's CLR Implementation	39	(1)
Global Assembly Cache Utility	40	(1)
XML Documentor	40	(1)
Outline Class Viewer	40	(1)
CIL Image Content Dumper	40	(1)
Intermediate Language Assembler	40	(1)
Certification Creation	40	(1)
Certificate Manager	40	(1)
Summary	40	(1)
Introducing C#	41	(22)
Exploring the Structure of a C# Program	41	(1)
Introducing Variables and Types	42	(8)
Introducing the Unified Type System	43	(1)
Value Types	43	(1)
Type Conversion	44	(1)
Reference Types	45	(1)
Enumerations	46	(1)
Arrays	46	(2)
Strings	48	(2)
Introducing Statements	50	(2)
Conditional Flow	50	(1)
Unconditional Flow	51	(1)
Loops	52	(1)
Introducing Classes	52	(2)
Methods	53	(1)
Properties and Attributes (or Fields)	53	(1)
Introducing Structures	54	(1)
Introducing Declarations	54	(1)
Defining Scope	55	(3)
Private	55	(1)
Public	56	(1)
Protected	56	(1)
Namespaces	56	(2)
Introducing Operators	58	(3)
Primary	59	(1)
Unary	59	(1)
Multiplicative	60	(1)
Additive	60	(1)
Shift	60	(1)
Relational	60	(1)
Equality	60	(1)
Logical Bitwise	60	(1)
Logical Boolean	61	(1)
Assignment	61	(1)
Summary	61	(2)
Learning C#: Beyond the Basics	63	(44)
What's Contained Within a Class or Struct?	63	(24)
Instance Construction and Destruction	64	(1)
Method Signatures	64	(1)
Constructors and Destructors	65	(2)
Scope Using Visibility Modifiers	67	(2)
Attributes	69	(1)
Operations	70	(6)
Constants	76	(1)
Enumerated Types	76	(1)
Fields and Properties	77	(2)
Overloaded Operators	79	(2)
Nested Types	81	(1)
Generalization, Specialization, and Initializers	81	(2)
Dynamic Method Behavior Through Polymorphism	83	(4)
Implementing and Using Interfaces	87	(2)
Understanding Events and Delegates	89	(4)
Handling Your Errors Through Exceptions	93	(4)
Catching Exceptions	93	(1)
Throwing Exceptions	94	(3)
Setting Scope Through Namespaces	97	(2)
Defining a Namespace	97	(1)
Using a Namespace	98	(1)
What's New in .NET 2.0?	99	(6)
Partial Types	99	(1)
Generics	100	(1)
Other Features	101	(4)
Summary	105	(2)
Exploring the .NET Core	107	(26)
Going Deeper into the Common Language Runtime (CLR)	107	(8)
Portable Executable (PE) File	108	(1)
Metadata	109	(1)
Intermediate Language (IL)	110	(2)
Class Loader	112	(1)
Verifier	112	(1)
Just-In-Time (JIT) Compiler	113	(1)
CLR Core	114	(1)
Using Assemblies	115	(5)
Introducing Modules	116	(1)
Creating an Assembly	116	(3)
Finding an Assembly	119	(1)
Introducing the Global Assembly Cache (GAC)	120	(2)
Adding Assemblies to the Cache	120	(1)
Verifying the Contents of the Cache	121	(1)
Removing Assemblies from the Cache	122	(1)
Managing Memory with the Garbage Collector	122	(4)
Reference-Counted Objects	123	(1)
Generations of Objects	123	(2)
A Good Garbage-Collecting Citizen	125	(1)
Direct Control of the Garbage Collector	125	(1)
Using Application Domains	126	(2)
Understanding Domain Sharing	126	(1)
Defining and Using Your Own Application Domain	127	(1)
Using the Class Library	128	(3)
System	130	(1)
System.IO	130	(1)
System.Collections	130	(1)
System.Security	130	(1)
System.Data	130	(1)
System.Net	130	(1)
System.XML	130	(1)
System.Web	130	(1)
System.Windows.Forms	131	(1)
Summary	131	(2)
Creating Windows Forms	133	(46)
Graphical User Interface (GUI) Overview	133	(2)
Graphic Display Interface Plus (GDI+)	134	(1)
Windows Forms	135	(1)
Windows Forms vs. Web Forms	135	(1)
Implementing Good User Interface Design	135	(1)
Creating the User Interface for the RSS Aggregator	136	(14)
Creating a Form	137	(5)
Modifying the Look of Your Form	142	(1)
Creating a Menu	143	(5)
Handling Events from Your Controls	148	(2)
Exploring Form Types	150	(4)
Multidocument Interfaces (MDIs) vs. Single-Document Interfaces (SDIs)	151	(2)
Modal vs. Modeless	153	(1)
Creating a Dialog Box	154	(11)
Adding Functionality Through Controls	155	(2)
Setting the Owner and Location of Your Controls	157	(2)
Interacting with the Dialog Box	159	(6)
Using Windows.Forms Controls	165	(10)
Panel	165	(2)
Label	167	(1)
TextBox	167	(1)
ListBox	168	(1)
DataGrid	169	(6)
What's New in Version 2.0?	175	(3)
Managing Layout in Your User Interface	175	(1)
Control Improvements	176	(2)
Summary	178	(1)
Introducing Gtk+, Glade, and User Interfaces	179	(26)
What Is Gtk+?	179	(1)
Getting Started with Gtk+	180	(1)
Using Glade for User Interface Design and Development	181	(5)
What Is Glade?	181	(1)
Navigating the Glade User Interface	182	(4)
Creating Your First Project	186	(9)
Creating Your RSS Aggregator's First Window Using Gtk#	189	(4)
Creating a Dialog Box	193	(2)
Examining Glade's Output	195	(1)
Using Glade's Programmatic Interface	196	(6)
What Do You Need?	196	(2)
Creating an Instance of a User Interface	198	(2)
Attaching Signal Event Handlers in Code Using C#	200	(2)
Displaying and Handling Your File Open Dialog Box	202	(1)
Comparing Glade and Windows Forms	202	(1)
Summary	203	(2)
Using ADO.NET	205	(36)
Overview of ADO.NET	205	(1)
Introducing Database Terms	206	(1)
Introducing Data Providers	207	(2)
Connection	208	(1)
Command	208	(1)
DataReader	208	(1)
DataAdapter	208	(1)
Introducing Content Components	209	(1)
DataReader	209	(1)
DataSet	209	(1)
DataTable	210	(1)
DataView	210	(1)
Installing a Data Provider	210	(7)
Why MySQL?	211	(1)
Installing MySQL on Linux	211	(1)
Installing MySQL on Windows	211	(5)
Using Common MySQL Command-Line Utilities	216	(1)
Creating a Database	216	(1)
Understanding Data Encapsulation Design	217	(5)
Data Access Layer	218	(3)
Data Storage Layer and Entities	221	(1)
Using the MySQL Data Provider	222	(4)
Installing a Database Connector	223	(1)
Connecting to a Database	223	(3)
Disconnecting from a Database	226	(1)
Reading Data from Your Database	226	(4)
Writing Data to Your Database	230	(2)
Deleting a Row	230	(1)
Inserting or Updating a Row Directly	231	(1)
Using the DataSet Class	232	(4)
Reading Data	232	(2)
Updating Data Within a DataSet	234	(2)
Supporting Transactions	236	(1)
Connecting Your Database to the User Interface	237	(2)
Summary	239	(2)
Using XML	241	(32)
Exploring the History of XML	242	(2)
What Is a Markup Language?	242	(1)
What Are the Origins of XML?	242	(1)
Why Do You Need XML?	242	(2)
Exploring the Structure of an XML Document	244	(10)
Introducing an XML Document's Elements	244	(1)
Introducing Elements, Attributes, and Content	245	(1)
Valid vs. Well-Formed Documents	246	(1)
Using XML Namespaces	247	(1)
Representing Data Using XML	248	(1)
Enforcing Data Integrity Using XML Schemas	249	(5)
Introducing XML-Related Technologies	254	(1)
Using the .NET Framework and XML Together	254	(2)
Creating the RSS Feed Class Library	256	(4)
Reading XML Documents	260	(2)
Traversing XML Documents	262	(5)
Initializing the Channel Attributes	262	(1)
Initializing the Optional ChannelImage Class	263	(1)
Reading the Channel Items	264	(3)
Writing XML Documents	267	(5)
Writing an XML Document	267	(2)
Updating an XML Document	269	(3)
Summary	272	(1)
Introducing Networking and Remoting	273	(34)
Overview of Networking Concepts	273	(6)
What Is a Network?	274	(1)
What Types of Networks Are There?	274	(1)
How Do All These Networks Connect?	275	(1)
How Do Applications Communicate over the Network?	275	(2)
How Do Machines Identify Themselves?	277	(1)
What Are the Internet, Intranet, and Extranet?	277	(1)
What Does a Typical Home Network Look Like?	278	(1)
Network Programming Using .NET	279	(3)
What Is System.Net?	279	(1)
Reading Pages from a Web Server	280	(2)
Writing the RSS Feed Handler	282	(3)
Establishing the Extensions to the Channel API	282	(1)
Establishing a Connection with an RSS Feed	283	(1)
Reading an RSS Feed	283	(1)
Using Proxy Servers	284	(1)
Integrating Network Capabilities into the Aggregator	285	(7)
Remoting Using .NET	292	(11)
What Is Remoting?	293	(3)
.NET Remoting Example	296	(7)
What's New in .NET 2.0?	303	(2)
Obtaining Network Information	304	(1)
Testing Connectivity	304	(1)
File Transfer Protocol (FTP) Support	304	(1)
Summary	305	(2)
Using ASP.NET	307	(40)
Overview of ASP.NET	307	(2)
What Is the World Wide Web?	307	(1)
What Components Are Required to Build a Web Site?	307	(1)
What Is ASP.NET?	308	(1)
Going Inside ASP.NET	309	(5)
Architecture	309	(1)
ASP.NET Page Components	309	(4)
ASP.NET's Execution Model	313	(1)
Installing a Web Server	314	(7)
Obtaining and Installing the XSP Web Server	314	(2)
Obtaining and Installing Apache	316	(3)
Connecting Mono to Your Web Server	319	(2)
Using Your Web Server	321	(14)
Testing Your Web Server	321	(4)
Building Your Own Web Site	325	(10)
Writing a Web Service	335	(9)
Overview of Web Service Terminology and Concepts	335	(1)
Creating Your Web Service	336	(2)
Adding a Web Service Method	338	(1)
Consuming a Web Service	339	(5)
What's New in ASP.NET 2.0?	344	(1)
Summary	345	(2)
Using Advanced Mono Techniques	347	(30)
Monitoring Your Performance	347	(8)
Using the Mono Profiler	348	(3)
Other Profiling Tools	351	(4)
Enhancing Your Performance	355	(7)
Fast String Manipulation	356	(2)
Avoid Boxing to Increase Performance	358	(1)
Using structs When Class Features Are Not Required	359	(1)
Helping Your Friend the Garbage Collector	360	(1)
Performance Interactions Using foreach	360	(1)
Other Quick-Fire Tips	361	(1)
Understanding Reflection	362	(3)
Using the Reflection API	363	(1)
What Else Can Reflection Show?	364	(1)
Processing Asynchronously Using Threads	365	(9)
What Are Processes and Threads?	365	(1)
.NET's Threading Support	365	(9)
Enhancing Interoperability	374	(2)
What Is Interoperability?	374	(1)
Achieving Interoperability	374	(2)
Summary	376	(1)
Index	377