Sams Teach Yourself C# in 24 Hours
provides readers with 24 structured lessons that provide a light, but
thorough introduction to C#. Readers are guided step-by-step through a
presentation of the basics of C#. Once the basics are
understood, the reader is shown how to apply this knowledge to
real-world Windows programming tasks using C#. Each chapter contains
exercises that reinforce the lessons learned in each chapter. Tips,
Notes, and Cautions provide additional advice from the authors on how
to get up to speed and programming quickly with C#. Sidebars provide
the more experienced reader with tips that will ease their migration
from Visual Basic 6 and Visual C++ to C#.
Chapters cover:
The Visual Studio Environment - provides an
overview of developing a project in C#. The reader learns all about the
C# interface, objects, collections, and events
Building a User Interface - learn how to build a
solid user interface including how to start with a form, how to use
controls such as text boxes and list boxes. This section also shows the
reader how to add menus and toolbars to forms, and there is information
on C#'s drawing and printing capabilities
Making Things Happen - Programming! - learn about the
C# syntax and how to create reusable code. Learn how to make decisions
in code and to build loops, as well as C#'s powerful debugging features
and object-oriented programming
Working with Data - teaches basic file operations
including the creation and deletion of files and folders. Readers also
lean about basic database skills, and how to use automation to control
the behaviour of other applications
Deploying Solutions and Beyond - learn how
to take a completed project and distribute it to users. There is also
an introduction to web development, and about the .NET platform at a
higher level
This book is targeted toward those who have little or no
programming experience. The book has been structured and written with a
purpose, and that is to get the reader productive as quickly and as
smoothly as possible.
.NET Book Zero - What the C or C++ Programmer Needs to
Know About C# and the .NET Framework is a book that provides an
introduction to C# and the Microsoft .NET Framework for programmers who
have experience with C or C++.
Chapters cover:
Why .NET?
Runtimes and SDKs
Edit, Compile, Run, Disassemble - discusses the
structure and contents of simple example programs
Strings and the Console - a string is an object of
type String whose value is text
Primitive Data Types - takes a more methodical
approach to data types of
string, char, int, double and the other primitive data types supported
by C# and the CLR
Operators and Expressions - operator precedence and
associativity, primary operators, unary operators, multiplicative and
arithmetic operators, shift operators, relational operators, equality
operators, logical operators and conditional operators, and assignment
operators
Selection and Iteration - discusses statements built
around the if, else, switch, case, default, do, while, for, foreach,
in, break, continue, and goto keywords
The Stack and the Heap - keep memory management and
garbage collection in mind in order to optimize the performance of
applications
Arrays - ordered collections of objects of the same
type
Methods and Fields
Exception Handling - examines C# support for
structured exception handling
Classes, Structures, and Objects
Instance Methods - when a method declaration does not
include a static modifier, the method is said to be an instance method
Constructors - enable the programmer to set
default values, limit instantiation, and write code that is flexible
and easy to read
Concepts of Equality - explore in more depth the
differences between classes (reference types) and structures (value
types)
Fields and Properties - classes and structures have
several types of members, most notably
fields, methods, constructors, and properties
Inheritance - one of the primary features of
object-oriented programming. Inheritance provides a structured way to
reuse code that has already been written, but inheritance also provides
a
way to alter or enhance the code in ways that make it more useful or
convenient
Virtuality
Operator Overloading - permits user-defined
operator implementations to be specified for operations where one or
both of the operands are of a user-defined class or struct type
Interfaces - an interface contains definitions for a
group of related functionalities that a class or a struct can implement
Interoperability - enables you to preserve
and take advantage of existing investments in unmanaged code
Dates and Times - a particular moment in time is
represented by an object of type DateTime, a structure defined in the
System namespace
Events and Delegates
Files and Streams
String Theory
Generics - a new feature in version 2.0 of the C#
language and the common language runtime (CLR). Generics introduce to
the .NET Framework the concept of type parameters, which make it
possible to design classes and methods that defer the specification of
one or more types until the class or method is declared and
instantiated by client code
Nullable Types - instances
of the System.Nullable struct
This book is freely distributable.
6. Data Structures and Algorithms
with Object-Oriented Design Patterns in C#
Data Structures and Algorithms with Object-Oriented
Design Patterns in C# is a book that promotes object-oriented design
using C# and to illustrate the use of the
emerging object-oriented design patterns. The book shows how patterns
are used to create good software designs. In particular, the following
design patterns are used throughout the text: singleton, container,
enumeration, adapter and visitor.
Virtually all of the data structures are presented in
the context of a single, unified, polymorphic class hierarchy. This
framework clearly shows the relationships between data structures and
it illustrates how polymorphism and inheritance can be used
effectively. In addition, algorithmic abstraction is used extensively
when presenting classes of algorithms. By using algorithmic
abstraction, it is possible to describe a generic algorithm without
having to worry about the details of a particular concrete realization
of that algorithm.
Data Structures and Algorithms with Object-Oriented
Design Patterns in C# also presents mathematical tools just in time.
Analysis techniques and proofs are presented as needed and in the
proper context.
Chapters cover:
Algorithm Analysis - examines a detailed model of
the computer and a simplified model of the computer
Asymptotic Notation - an asymptotic upper bound-big
oh, an asymptotic lower bound-omega, notation-thea and little
oh, and asymptotic analysis of algorithms
Foundational Data Structures - considers arrays,
multi-dimensional arrays and singly-linked lists, discussing
in detail the implementation of a singly-linked list class, LinkedList
Data Types and Abstraction - abstract data types,
and design patterns
Stacks, Queues, and Deques - considers
several related abstract data types
Ordered Lists and Sorted Lists - considers
two kinds of lists: ordered lists and sorted lists.
In an ordered list the order of the items is significant. A sorted list
is one in which the order of the items is defined by some collating
sequence
Hashing, Hash Tables, and Scatter Tables - examines
hashing methods, hash function implementations, hash tables, scatter
tables, and scatter table using open addressing
Trees - one of the most important non-linear
information structures. This chapter considers several different kinds
of trees as well as several different tree traversal algorithms.
In addition, the reader explores how trees can be used to represent
arithmetic expressions and how they can evaluate an arithmetic
expression by doing a tree traversal
Search Trees - considers trees that are
designed to support efficient search operations
Heaps and Priority Queues - looks at binary heaps,
leftist heaps, binomial queues
Sets, Multisets, and Partitions - examines array and
bit-vector sets, multisets, and partitions
Garbage Collection and the Other Kind of Heap -
teaches reference counting garbage collection, mark-and-sweep garbage
collection, stop-and-copy garbage collection, and mark-and-compact
garbage collection
Algorithmic Patterns and Problem Solvers - presents
a number of different algorithmic patterns including direct solution
strategies, backtracking strategies, top-down solution strategies,
bottom-up solution strategies, and randomized strategies
Sorting Algorithms and Sorters - looks at insertion,
exchange, selection, merge, and distribution sorting
Graphs and Graph Algorithms - a brief introduction
to the body of knowledge known as graph theory. It covers the most
common data structures for the representation of graphs
and introduces some fundamental graph algorithms
C# and Object-Oriented Programming - a
brief overview of programming in C#. It identifies and describes the
features of C# that are used throughout the book
