+ Reply to Thread
Page 1 of 7 1 2 3 ...
Results 1 to 10 of 66

 

Thread: كتب c# باللغة الانجليزية

  • Thread Tools
  1. #1 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post

    كتب c# باللغة الانجليزية

    The quest for the perfect programming language is as old as the discipline of programming itself.
    In this quest, C# is the current standard bearer. Created by Microsoft to support development
    for its .NET Framework, C# leverages time-tested features with cutting-edge innovations and
    provides a highly usable, efficient way to write programs for the modern enterprise computing
    environment. In the course of this book, you will learn to program using it.
    The purpose of this chapter is to introduce C#, including the forces that drove its creation,
    its design philosophy, and several of its most important features. By far, the hardest thing
    about learning a programming language is the fact that no element exists in isolation. Instead,
    the components of the language work together. It is this interrelatedness that makes it difficult
    to discuss one aspect of C# without involving others. To overcome this problem, this chapter
    provides a brief overview of several C# features, including the general form of a C# program,
    two control statements, and several operators. It does not go into too many details, but rather
    concentrates on the general concepts common to any C# program.
    At this time, version 3.0 is the current release of C#, and this is the version taught in this
    book. Of course, much of the information presented here applies to all versions of C#.
    C#’s Family Tree
    Computer languages do not exist in a void. Rather, they relate to one another, with each new
    language influenced in one form or another by the ones that came before. In a process akin
    to cross-pollination, features from one language are adapted by another, a new innovation is
    integrated into an existing context, or an older construct is removed. In this way, languages
    evolve and the art of programming advances. C# is no exception.


    ---------- Post added at 08:21 PM ---------- Previous post was at 08:20 PM ----------

    C# inherits a rich programming legacy. It is directly descended from two of the world’s
    most successful computer languages: C and C++. It is closely related to another: Java.
    Understanding the nature of these relationships is critical to understanding C#. Thus, we begin
    our examination of C# by placing it in the historical context of these three languages.
    C: The Beginning of the Modern Age of Programming
    The creation of C marks the beginning of the modern age of programming. C was invented by
    Dennis Ritchie in the 1970s on a DEC PDP-11 that used the UNIX operating system. While
    some earlier languages, most notably Pascal, had achieved significant success, it was C that
    established the paradigm that still charts the course of programming today.
    C grew out of the structured programming revolution of the 1960s. Structured languages are
    defined by their rich set of well-designed control statements, subroutines with local variables,
    code blocks, and other improvements that make it easier to organize and maintain a program.
    Although other languages at the time had similar features, C implemented these elements using
    a terse yet easy-to-use syntax. It also embodied a philosophy that put the programmer (not the
    language) at the center of the development process. As a result, C quickly won many converts.
    It became the dominant structured programming language of the late 1970s and 1980s, and it
    remains so to this day.
    The Creation of OOP and C++
    As useful as C is, by the late 1970s, the size of many projects was near or at the limits of what
    structured programming methodologies and the C language could handle. Programs were
    simply becoming too large. To address this problem, a new way to program began to emerge.
    This method is called object-oriented programming (OOP for short). Using OOP, a programmer
    could handle much larger programs. The trouble was that C, the most popular language at the
    time, did not support object-oriented programming. The desire for an object-oriented version of
    C ultimately led to the creation of C++.
    C++ was invented by Bjarne Stroustrup, beginning in 1979, at Bell Laboratories in Murray
    Hill, New Jersey. He initially called the new language “C with Classes.” However, in 1983, the
    name was changed to “C++.” C++ contains the entire C language. Thus, C is the foundation
    upon which C++ is built. Most of the additions that Stroustrup made to C were designed to
    support object-oriented programming. In essence, C++ is the object-oriented version of C.
    By building upon the foundation of C, Stroustrup provided a smooth migration path to
    OOP. Instead of having to learn an entirely new language, a C programmer needed to learn only
    a few new features before reaping the benefits of the object-oriented methodology. This made
    it easy for legions of programmers to make the shift from structured programming to objectoriented
    programming. As a result, by the second half of the 1990s, C++ became the preeminent
    language for the development of high-performance code.
    It is critical to understand that the invention of C++ was not an attempt to create a new
    programming language. Instead, it was an enhancement to an already highly successful
    language. This approach to language development—beginning with an existing language and
    moving it forward—established a trend that continues today.

    ---------- Post added at 08:22 PM ---------- Previous post was at 08:21 PM ----------

    The Internet and Java Emerge
    The next major advance in programming languages was Java. Work on Java, which was originally
    called Oak, began in 1991 at Sun Microsystems. The main driving force behind Java’s design was
    James Gosling. Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan also played a role.
    Java is a structured, object-oriented language with a syntax and philosophy derived
    from C++. The innovative aspects of Java were driven not so much by advances in the art
    of programming (although some certainly were), but rather by changes in the computing
    environment. Prior to the mainstreaming of the Internet, most programs were written, compiled,
    and targeted for a specific CPU and a specific operating system. While it has always been
    true that programmers like to reuse their code, the ability to easily port a program from one
    environment to another took a backseat to more pressing problems. However, with the rise of
    the Internet, in which many different types of CPUs and operating systems are connected, the
    old problem of portability became substantially more important. To solve this problem, a new
    language was needed, and this new language was Java.
    Java achieved portability by translating a program’s source code into an intermediate
    language called bytecode. This bytecode was then executed by the Java Virtual Machine (JVM).
    Therefore, a Java program could run in any environment for which a JVM was available. Also,
    since the JVM is relatively easy to implement, it was readily available for a large number of
    environments.
    In addition to the need for portability, there was a second fundamental problem that
    needed to be solved before Internet-based programming could become a reality. This problem
    was security. As all Internet users know, computer viruses constitute a serious and on-going
    potential threat. What good would portable programs be if no one could trust them? Who
    would want to risk executing a program delivered via the Internet? It might contain malicious
    code. Fortunately, the solution to the security problem is also found in the JVM and bytecode.
    Because the JVM executes the bytecode, it has full control of the program and can prevent a
    Java program from doing something that it shouldn’t. Thus, the JVM and bytecode solved both
    the issues of portability and security.
    It is key to understand that Java’s use of bytecode differed radically from both C and C++,
    which were nearly always compiled to executable machine code. Machine code is tied to a
    specific CPU and operating system. Thus, if you wanted to run a C/C++ program on a different
    system, it needed to be recompiled to machine code specifically for that environment. To create
    a C/C++ program that would run in a variety of environments, several different executable
    versions of the program were needed. Not only was this impractical, it was also expensive.
    Java’s use of an intermediate language was an elegant and cost-effective solution. It was also
    a solution that C# would adapt for its own purposes.
    As mentioned, Java is descended from C and C++. Its syntax is based on C, and its
    object model is evolved from C++. Although Java code is neither upwardly nor downwardly
    compatible with C or C++, its syntax is sufficiently similar that the large pool of existing C/C++
    programmers could move to Java with very little effort. Furthermore, because Java built upon
    and improved an existing paradigm, Gosling, et al., were free to focus their attentions on the
    new and innovative features. Just as Stroustrup did not need to “reinvent the wheel” when
    creating C++, Gosling did not need to create an entirely new language when developing Java.

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  2. #2 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    Moreover, with the creation of Java, C and C++ became an accepted substrata upon which to
    build a new computer language.
    The Creation of C#
    While Java has successfully addressed many of the issues surrounding portability and security
    in the Internet environment, there are still features that it lacks. One is cross-language
    interoperability, also called mixed-language programming. This is the ability for the code
    produced by one language to work easily with the code produced by another. Cross-language
    interoperability is crucial for the creation of large, distributed software systems. It is also
    desirable for programming software components, because the most valuable component is
    one that can be used by the widest variety of computer languages in the greatest number of
    operating environments.
    Another feature lacking in Java is full integration with the Windows platform. Although
    Java programs can be executed in a Windows environment (assuming that the Java Virtual
    Machine has been installed), Java and Windows are not closely coupled. Since Windows is
    the mostly widely used operating system in the world, lack of direct support for Windows is a
    drawback to Java.
    To answer these and other needs, Microsoft developed C#. C# was created at Microsoft late
    in the 1990s and was part of Microsoft’s overall .NET strategy. It was first released in its alpha
    version in the middle of 2000. C#’s chief architect was Anders Hejlsberg.
    C# is directly related to C, C++, and Java. This is not by accident. These are three of the
    most widely used—and most widely liked—programming languages in the world. Furthermore,
    nearly all professional programmers today know C, C++, or Java. By building C# upon a solid,
    well-understood foundation, C# offers an easy migration path from these languages. Since it was
    neither necessary nor desirable for Hejlsberg to “reinvent the wheel,” he was free to focus on
    specific improvements and innovations.
    The family tree for C# is shown in Figure 1-1. The *****father of C# is C. From C, C#
    derives its syntax, many of its keywords, and operators. C# builds upon and improves the object
    model defined by C++. If you know C or C++, you will feel at home with C#.

    ---------- Post added at 08:23 PM ---------- Previous post was at 08:23 PM ----------

    C# and Java have a bit more complicated relationship. As explained, Java is also descended
    from C and C++. It, too, shares the C/C++ syntax and object model. Like Java, C# is designed
    to produce portable code, and C# programs execute in a secure controlled runtime environment.
    However, C# is not descended from Java. Instead, C# and Java are more like cousins, sharing a
    common ancestry, but differing in many important ways. The good news, though, is that if you
    know Java, many C# concepts will be familiar. Conversely, if in the future you need to learn
    Java, many of the things you learn about C# will carry over.
    C# contains many innovative features that we will examine at length throughout the course
    of this book, but some of its most important features relate to its built-in support for software
    components. In fact, C# has been characterized as being a component-oriented language because
    it contains integral support for the writing of software components. For example, C# includes
    features that directly support constituents of components, such as properties, methods, and
    events. However, C#’s ability to work in a secure, mixed-language environment is perhaps its
    most important component-oriented feature.
    The Evolution of C#
    Since its original 1.0 release, C# has been evolving at a rapid pace. Not long after C# 1.0,
    Microsoft released version 1.1. It contained many minor tweaks, but added no major features.
    However, the situation was much different with the release of C# 2.0. This was a watershed
    event in the lifecycle of C# because version 2.0 added many new features, such as generics,
    partial types, and anonymous methods, that fundamentally expanded the scope, power,
    and range of the language. Version 2.0 firmly put C# at the forefront of computer language
    development. It also demonstrated Microsoft’s long-term commitment to the language.
    The next major release of C# was 3.0, and (at the time of this writing) this is the current
    version of C#. Because of the many new features added by C# 2.0, one might have expected
    the development of C# to slow a bit, just to let programmers catch up, but this was not the case.
    With version 3.0, Microsoft once again put C# on the cutting edge of language design, this time
    adding a set of innovative features that redefined the programming landscape.
    Perhaps the two most exciting new features in C# 3.0 are language-integrated query
    (LINQ) and lambda expressions. LINQ enables you to write database queries using C#
    programming elements. Lambda expressions are often used in LINQ expressions. Together
    they add an entirely new dimension to C# programming. Other innovations include implicitly
    typed variables and extension methods. Because this book is based on C# 3.0, these important
    advances are covered.
    How C# Relates to the .NET Framework
    Although C# is a computer language that can be studied on its own, it has a special
    relationship to its runtime environment, the .NET Framework. The reason for this is twofold.
    First, C# was initially designed by Microsoft to create code for the .NET Framework. Second,
    the libraries used by C# are the ones defined by the .NET Framework. Thus, even though it is

    ---------- Post added at 08:24 PM ---------- Previous post was at 08:23 PM ----------

    possible to separate the C# language from the .NET environment, the two are closely linked.

    ---------- Post added at 08:24 PM ---------- Previous post was at 08:24 PM ----------

    Because of this, it is important to have a general understanding of the .NET Framework and
    why it is important to C#.
    What Is the .NET Framework?
    In a sentence, the .NET Framework defines an environment that supports the development and
    execution of highly distributed, component-based applications. It enables different computer
    languages to work together and provides for security, program portability, and a common
    programming model for the Windows platform.
    As it relates to C#, the .NET Framework defines two very important entities. The first is the
    Common Language Runtime. This is the system that manages the execution of your program.
    Along with other benefits, the Common Language Runtime is the part of the .NET Framework
    that enables programs to be portable, supports mixed-language programming, and provides for
    security.
    The second entity is the .NET class library. This library gives your program access to the
    runtime environment. For example, if you want to perform I/O, such as displaying something
    on the screen, you will use the .NET class library to do it. If you are new to programming, the
    term class may be new. Although it will be explained in detail a bit later, briefly, a class is an
    object-oriented construct that helps organize programs. As long as your program restricts itself
    to the features defined by the .NET class library, your programs can run anywhere that the .NET
    runtime system is supported. Since C# automatically uses the .NET class library, C# programs
    are automatically portable to all .NET environments.

    ---------- Post added at 08:25 PM ---------- Previous post was at 08:24 PM ----------

    How the Common Language Runtime Works
    The Common Language Runtime (CLR) manages the execution of .NET code. Here is how
    it works. When you compile a C# program, the output of the compiler is not executable code.
    Instead, it is a file that contains a special type of pseudocode called Microsoft Intermediate
    Language, or MSIL for short. MSIL defines a set of portable instructions that are independent
    of any specific CPU. In essence, MSIL defines a portable assembly language. One other point:
    Although MSIL is similar in concept to Java’s bytecode, the two are not the same.
    It is the job of the CLR to translate the intermediate code into executable code when a
    program is run. Thus, any program compiled to MSIL can be run in any environment for which
    the CLR is implemented. This is part of how the .NET Framework achieves portability.
    Microsoft Intermediate Language is turned into executable code using a JIT compiler. JIT
    stands for “just in time.” The process works like this: When a .NET program is executed, the
    CLR activates the JIT compiler. The JIT compiler converts MSIL into native code on a demand
    basis, as each part of your program is needed. Thus, your C# program actually executes as
    native code, even though it was initially compiled into MSIL. This means that your program
    runs nearly as fast as it would if it had been compiled to native code in the first place, but it
    gains the portability and security benefits of MSIL.
    In addition to MSIL, one other thing is output when you compile a C# program: metadata.
    Metadata describes the data used by your program and enables your code to interact with other
    code. The metadata is contained in the same file as the MSIL.

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  3. #3 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    Fortunately, for the purposes of this book, and for the majority of programming tasks, it
    is not necessary to know any more about the CLR, MSIL, or metadata. C# handles the details
    for you.
    Managed vs. Unmanaged Code
    In general, when you write a C# program, you are creating what is called managed code.
    Managed code is executed under the control of the Common Language Runtime, as just
    described. Because it is running under the control of the CLR, managed code is subject to
    certain constraints—and derives several benefits. The constraints are easily described and met:
    The compiler must produce an MSIL file targeted for the CLR (which C# does) and use the
    .NET Framework library (which C# does). The benefits of managed code are many, including
    modern memory management, the ability to mix languages, better security, support for version
    control, and a clean way for software components to interact.
    The opposite of managed code is unmanaged code. Unmanaged code does not execute
    under the Common Language Runtime. Thus, all Windows programs prior to the creation of the
    .NET Framework use unmanaged code. It is possible for managed code and unmanaged code to
    work together, so the fact that C# generates managed code does not restrict its ability to operate
    in conjunction with preexisting programs.

    ---------- Post added at 08:26 PM ---------- Previous post was at 08:26 PM ----------

    The Common Language Specification
    Although all managed code gains the benefits provided by the CLR, if your code will be used
    by other programs written in different languages, for maximum usability, it should adhere to
    the Common Language Specification (CLS). The CLS describes a set of features, such as data
    types, that different languages have in common. CLS compliance is especially important when
    creating software components that will be used by other languages. Although we won’t need to
    worry about the CLS for the purposes of this book, it is something you will want to look into
    when you begin writing commercial code.
    Q: To address the issues of portability, security, and mixed-language programming, why
    was it necessary to create a new computer language such as C#? Couldn’t a language
    like C++ be adapted to support the .NET Framework?
    A: Yes, it is possible to adapt C++ so that it produces .NET-compatible code that runs under
    the CLR. In fact, Microsoft did just that. Initially, Microsoft added what are called the
    managed extensions to C++. However, this approach has been rendered obsolete and is
    replaced by a set of extended keywords and syntax defined by the Ecma C++/CLI Standard.
    (CLI stands for Common Language Infrastructure.) Although C++/CLI make it possible to
    port existing code to the .NET Framework, new .NET development is much easier in C#
    because it was originally designed with .NET in mind.

    ---------- Post added at 08:27 PM ---------- Previous post was at 08:26 PM ----------

    Object-Oriented Programming
    At the center of C# is object-oriented programming (OOP). The object-oriented methodology is
    inseparable from C#, and all C# programs are, at least to some extent, object-oriented. Because
    of its importance to C#, it is useful to understand OOP’s basic principles before you write even
    a simple C# program.
    OOP is a powerful way to approach the job of programming. Programming methodologies
    have changed dramatically since the invention of the computer, primarily to accommodate
    the increasing complexity of programs. For example, when computers were first invented,
    programming was done by toggling in the binary machine instructions using the computer’s
    front panel. As long as programs were just a few hundred instructions long, this approach
    worked. As programs grew, assembly language was invented so that a programmer could deal
    with larger, increasingly complex programs, using symbolic representations of the machine
    instructions. As programs continued to grow, high-level languages, such as FORTRAN
    and COBOL, were introduced that gave the programmer more tools with which to handle
    complexity. When these early languages began to reach their breaking point, structured
    programming was invented.

    ---------- Post added at 08:27 PM ---------- Previous post was at 08:27 PM ----------

    Consider this: At each milestone in the development of programming, techniques and tools
    were created to allow the programmer to deal with increasingly greater complexity. Each step of
    the way, the new approach took the best elements of the previous methods and moved forward.
    The same is true of object-oriented programming. Prior to OOP, many projects were nearing
    (or exceeding) the point where the structured approach no longer worked. A better way to
    handle complexity was needed, and object-oriented programming was the solution.
    Object-oriented programming took the best ideas of structured programming and combined
    them with several new concepts. The result was a different and better way of organizing a
    program. In the most general sense, a program can be organized in one of two ways: around
    its code (what is happening) or around its data (what is being affected). Using only structured
    programming techniques, programs are typically organized around code. This approach can be
    thought of as “code acting on data.”
    Object-oriented programs work the other way around. They are organized around data, with
    the key principle being “data controlling access to code.” In an object-oriented language, you
    define the data and the routines that are permitted to act on that data. Thus, a data type defines
    precisely what sort of operations can be applied to that data.
    To support the principles of object-oriented programming, all OOP languages, including C#,
    have three traits in common: encapsulation, polymorphism, and inheritance. Let’s examine each.

    ---------- Post added at 08:28 PM ---------- Previous post was at 08:27 PM ----------

    Encapsulation
    Encapsulation is a programming mechanism that binds together code and the data it manipulates,
    and keeps both safe from outside interference and misuse. In an object-oriented language, code
    and data can be bound together in such a way that a self-contained black box is created. Within
    the box are all necessary data and code. When code and data are linked together in this fashion, an
    object is created. In other words, an object is the device that supports encapsulation.
    Within an object, code, data, or both may be private to that object or public. Private code or
    data is known to and accessible by only another part of the object. That is, private code or data
    cannot be accessed by a piece of the program that exists outside the object. When code or data
    is public, other parts of your program can access it, even though it is defined within an object.
    Typically, the public parts of an object are used to provide a controlled interface to the private
    elements of the object.

    ---------- Post added at 08:29 PM ---------- Previous post was at 08:28 PM ----------

    specifies both the data and the code that will operate on that data. C# uses a class specification
    to construct objects. Objects are instances of a class. Thus, a class is essentially a set of plans
    that specify how to build an object.
    The code and data that constitute a class are called members of the class. Specifically,
    the data defined by the class is referred to as member variables or instance variables. The
    code that operates on that data is referred to as member methods or just methods. “Method”
    is C#’s term for a subroutine. If you are familiar with C/C++, it may help to know that what a
    C# programmer calls a method, a C/C++ programmer calls a function. Because C# is a direct
    descendent of C++, the term “function” is also sometimes used when referring to a C# method.
    Polymorphism
    Polymorphism (from Greek, meaning “many forms”) is the quality that allows one interface to
    access a general class of actions. A simple example of polymorphism is found in the steering
    wheel of an automobile. The steering wheel (the interface) is the same, no matter what type of
    actual steering mechanism is used. That is, the steering wheel works the same whether your
    car has manual steering, power steering, or rack-and-pinion steering. Thus, turning the steering
    wheel left causes the car to go left no matter what type of steering is used. The benefit of the
    uniform interface is, of course, that once you know how to operate the steering wheel, you can
    drive any type of car

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  4. #4 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    The same principle can also apply to programming. For example, consider a stack (which
    is a first-in, last-out list). You might have a program that requires three different types of stacks.
    One stack is used for integer values, one for floating-point values, and one for characters. In this
    case, the algorithm that implements each stack is the same, even though the data being stored
    differs. In a non–object-oriented language, you would be required to create three different sets
    of stack routines, with each set using different names. However, because of polymorphism,
    in C#, you can specify the general form of a stack once and then use it for all three specific
    situations. This way, if you know how to use one stack, you can use them all.
    More generally, the concept of polymorphism is often expressed by the phrase “one
    interface, multiple methods.” This means that it is possible to design a generic interface to
    a group of related activities. Polymorphism helps reduce complexity by allowing the same
    interface to be used to specify a general class of action. It is the compiler’s job to select the
    specific action (that is, method) as it applies to each situation. You, the programmer, don’t need
    to do this selection manually. You need only remember and utilize the general interface.
    Inheritance
    Inheritance is the process by which one object can acquire the properties of another object. This
    is important because it supports the concept of hierarchical classification. If you think about it,
    most knowledge is made manageable by hierarchical (that is, top-down) classifications.

    ---------- Post added at 08:30 PM ---------- Previous post was at 08:29 PM ----------

    Q: You state that object-oriented programming is an effective way to manage large
    programs. However, it seems that OOP might add substantial overhead to relatively
    small programs. Since you say that all C# programs are, to some extent, objectoriented,
    does this impose a penalty for smaller programs?
    A: No. As you will see, for small programs, C#’s object-oriented features are nearly transparent.
    Although it is true that C# follows a strict object model, you have wide latitude as to the
    degree to which you employ it. For smaller programs, their “object-orientedness” is barely
    perceptible. As your programs grow, you will integrate more object-oriented features
    effortlessly.

    ---------- Post added at 08:31 PM ---------- Previous post was at 08:30 PM ----------

    For example, a Red Delicious apple is part of the classification apple, which, in turn, is part
    of the fruit class, which is under the larger class food. That is, the food class possesses certain
    qualities (edible, nutritious, and so on) that also, logically, apply to its subclass, fruit. In addition
    to these qualities, the fruit class has specific characteristics (juicy, sweet, and so forth) that
    distinguish it from other food. The apple class defines those qualities specific to an apple (grows
    on trees, not tropical, and so on). A Red Delicious apple would, in turn, inherit all the qualities of
    all preceding classes and would define only those qualities that make it unique.
    Without the use of hierarchies, each object would have to explicitly define all of its
    characteristics. Using inheritance, an object need only define those qualities that make it unique
    within its class. It can inherit its general attributes from its parent. Thus, it is the inheritance
    mechanism that makes it possible for one object to be a specific instance of a more general case.
    Creating, Compiling, and Running
    Your First C# Program
    It is now time to learn how to create, compile, and run a C# program. Since this is a “hands-on”
    guide to C# programming, being able to successfully complete these tasks is a necessary first
    step. Here is the program we will use:
    /*
    This is a simple C# program.
    Call this program Example.cs.
    */
    using System;
    class Example {

    ---------- Post added at 08:31 PM ---------- Previous post was at 08:31 PM ----------

    // A C# program begins with a call to Main().
    static void Main() {
    Console.WriteLine("C# gives you programming power.");
    }
    }
    Although quite short, this program does contain several key features that are common to all C#
    programs. Once you have learned how to compile and run it, we will examine it in detail.
    Obtain a C# 3.0 Compiler
    To create, compile, and run a C# program, you will need a copy of Microsoft’s Visual C#. This
    book uses Visual C# 2008, which is the compiler that supports C# 3.0. Although many of the
    programs in this book can be compiled by an earlier version of C#, you will need Visual C#
    2008 to handle the newer features.
    If you do not currently have Visual C# 2008, you will need to acquire it. Microsoft supplies
    Visual C# 2008 in a variety of forms, including its commercial offerings, which can be
    purchased. However, at the time of this writing, you can also obtain a copy free of charge by
    downloading an Express edition. Visual C# Express edition contains a full-featured compiler
    that supports all of C# 3.0 and is, therefore, able to compile all of the code in this book. It
    also includes Visual Studio, which is Microsoft’s integrated development environment (IDE).
    Although the Express edition does not supply all of the tools that a commercial developer will
    want, it is perfect for learning C#. At the time of this writing, Visual C# 2008 Express can be
    downloaded from www.microsoft.com/express. All of the code in this book has been tested
    against this compiler.
    Using Visual C#, there are two general approaches you can take to creating, compiling,
    and running a C# program. First, you can use the Visual Studio IDE. Second, you can use the
    command-line compiler, csc.exe. Both methods are described here.

    ---------- Post added at 08:32 PM ---------- Previous post was at 08:31 PM ----------

    Using the Visual Studio IDE
    As mentioned, Visual Studio is Microsoft’s integrated programming environment. It lets
    you edit, compile, run, and debug a C# program, all without leaving its well thought-out
    environment. Visual Studio offers convenience and helps manage your programs. It is most
    effective for larger projects, but it can be used to great success with smaller programs, such as
    those that constitute the examples in this book.
    The steps required to edit, compile, and run a C# program using the Visual Studio 2008 IDE
    are shown here. These steps assume that you are using the IDE provided by Visual C# Express
    2008. Slight differences may exist with other versions of Visual Studio 2008.
    1. Create a new, empty C# project by selecting File | New Project. Next, select Empty Project.

    ---------- Post added at 08:33 PM ---------- Previous post was at 08:32 PM ----------

    Using csc.exe, the C# Command-Line Compiler
    Although the Visual Studio IDE is what you will probably be using for your commercial
    projects, some readers will find the C# command-line compiler more convenient, especially
    for compiling and running the sample programs shown in this book. The reason is that you
    don’t have to create a project for the program. You can simply create the program, then compile
    it, and run it—all from the command line. Therefore, if you know how to use the Command
    Prompt window and its command-line interface, using the command-line compiler will be faster
    and easier than using the IDE.

    ---------- Post added at 08:34 PM ---------- Previous post was at 08:33 PM ----------

    If you are not familiar with the Command Prompt window, it is probably better to use the
    Visual Studio IDE. Although its commands are not difficult to learn, trying to learn both
    the Command Prompt and C# at the same time will be a challenging experience.
    To create and run programs using the C# command-line compiler, follow these three steps:
    1. Enter the program using a text editor.
    2. Compile the program using csc.exe.
    3. Run the program.
    Entering the Program
    As mentioned, the programs shown in this book are available from Mcgraw-Hill’s website:
    www.mhprofessional.com. However, if you want to enter the programs by hand, you are free
    to do so. In this case, you must enter the program into your computer using a text editor, such
    as Notepad. Remember, you must create text-only files, not formatted word-processing files,
    because the format information in a word processor file will confuse the C# compiler. When
    entering the program, call the file Example.cs.

    ---------- Post added at 08:34 PM ---------- Previous post was at 08:34 PM ----------

    Compiling the Program
    To compile the program, execute the C# compiler, csc.exe, specifying the name of the source
    file on the command line, as shown here:
    C:\>csc Example.cs
    The csc compiler creates a file called Example.exe that contains the MSIL version of the
    program. Although MSIL is not executable code, it is still contained in an exe file. The
    Common Language Runtime automatically invokes the JIT compiler when you attempt to
    execute Example.exe. Be aware, however, that if you try to execute Example.exe (or any other
    exe file that contains MSIL) on a computer for which the .NET Framework is not installed, the
    program will not execute, because the CLR will be missing.

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  5. #5 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    NOTE
    Prior to running csc.exe, you will need to **** a Command Prompt window that is
    configured for Visual Studio. The easiest way to do this is to select “Visual Studio 2008
    Command Prompt” under Visual Studio Tools in the Start menu. Alternatively, you can
    start an unconfigured Command Prompt window and then run the batch file vsvars32
    .bat, which is provided by Visual Studio. You may, however, encounter a problem with
    the command-line approach. At the time of this writing, Visual C# 2008 Express edition
    does not provide the Visual Studio Tools menu or the vsvars32.bat file. Therefore, if
    you are using Visual C# Express, you may not be able to automatically configure a
    Command Prompt window. In this case, use the Visual Studio IDE instead. However,
    Visual C++ 2008 Express edition does supply both vsvars32.bat and the “Visual Studio
    2008 Command Prompt” menu selection. Therefore, if you also install Visual C++
    2008 Express Edition, you will be able to start a properly configured Command Prompt
    window that will also work for C#.

    ---------- Post added at 08:36 PM ---------- Previous post was at 08:35 PM ----------

    Running the Program
    To actually run the program, just type its name on the command line, as shown here:
    C:\>Example
    When the program runs, the following output is displayed:
    C# gives you programming power.
    The First Example Program Line by Line
    Although Example.cs is quite short, it includes several key features that are common to all C#
    programs. Since this is your first C# program, it warrants close examination. We will begin with
    its name.
    The name of a C# program can be chosen arbitrarily. Unlike some computer languages
    (most notably, Java) in which the name of a program file is very important, this is not the
    case for C#. You were told to call the sample program Example.cs so that the instructions for
    compiling and running the program would apply, but as far as C# is concerned, you could have
    called the file by another name. For example, the preceding sample program could have been
    called Sample.cs, Test.cs, or even MyProg.cs.
    By convention, C# programs use the .cs file extension, and this is a convention that you
    should follow. Also, many programmers call a file by the name of the principal class defined
    within the file. This is why the filename Example.cs was chosen. Since the names of C#
    programs are arbitrary, names won’t be specified for most of the sample programs in this book.
    Just use names of your own choosing.
    The program begins with the following lines:
    /*
    This is a simple C# program.
    Call this program Example.cs.
    */

    ---------- Post added at 08:37 PM ---------- Previous post was at 08:36 PM ----------

    This is a comment. Like most other programming languages, C# lets you enter remarks into
    a program’s source file. The contents of a comment are ignored by the compiler. Instead, a
    comment describes or explains the operation of the program to anyone who is reading its source
    code. In this case, the comment describes the program and reminds you to call the source file
    Example.cs. Of course, in real applications, comments generally explain how some part of the
    program works or what a specific feature does.
    C# supports three styles of comments. The one shown at the top of the program is called
    a multiline comment. This type of comment must begin with /* and end with */. Anything
    between these two comment symbols is ignored by the compiler. As the name suggests, a
    multiline comment can be several lines long.
    The next line in the program is
    using System;

    ---------- Post added at 08:38 PM ---------- Previous post was at 08:37 PM ----------

    This line indicates that the program is using the System namespace. In C#, a namespace defines
    a declarative region. Although we will look at the namespaces in detail later, a brief description
    is useful now. A namespace provides a way to keep one set of names separate from another. In
    essence, names declared in one namespace will not conflict with the same names declared in
    another. The namespace used by the program is System, which is the namespace reserved for
    items associated with the .NET Framework class library, which is the library used by C#. The
    using keyword states that the program is using the names in the given namespace.
    The next line of code in the program is shown here:
    class Example {
    This line uses the keyword class to declare that a new class is being defined. As mentioned, the
    class is C#’s basic unit of encapsulation. Example is the name of the class. The class definition
    begins with the ****ing curly brace ({) and ends with the closing curly brace (}). The elements
    between the two braces are members of the class. For the moment, don’t worry too much about
    the details of a class, except to note that program activity occurs within one.
    The next line in the program is a single-line comment, shown here:
    // A C# program begins with a call to Main().
    This is the second type of comment supported by C#. A single-line comment begins with
    a // and ends at the end of the line. As a general rule, programmers use multiline comments for
    longer remarks and single-line comments for brief, line-by-line descriptions.
    The next line of code is shown here:
    static void Main() {
    This line begins the Main( ) method. As mentioned earlier, in C#, a subroutine is called a
    method. As the comment preceding it suggests, this is the line at which the program will begin
    executing. All C# applications begin execution by calling Main( ). The complete meaning of
    each part of this line cannot be given now, since it involves a detailed understanding of several
    other C# features. However, since many of the examples in this book will use this line of code,
    a brief explanation is warranted.

    ---------- Post added at 08:39 PM ---------- Previous post was at 08:38 PM ----------

    The line begins with the keyword static. A method that is modified by static can be called
    before an object of its class has been created. This is necessary because Main( ) is called at
    program startup. The keyword void indicates that Main( ) does not return a value. As you will
    see, methods can also return values. The empty parentheses that follow Main indicate that no
    information is passed to Main( ). As you will also see, it is possible to pass information into
    Main( ) or into any other method. The last character on the line is the {. This signals the start
    of Main( )’s body. All of the code that comprises a method will occur between the method’s
    ****ing curly brace and its closing curly brace.
    The next line of code is shown here. Notice that it occurs inside Main( ).
    Console.WriteLine("C# gives you programming power.");

    ---------- Post added at 08:39 PM ---------- Previous post was at 08:39 PM ----------

    Q: You said that C# supports three types of comments, but you only mentioned two.
    What is the third?
    A: The third type of comment supported by C# is a documentation comment, also called
    an XML comment. A documentation comment uses XML tags to help you create selfdocumenting
    code.
    This line outputs the string “C# gives you programming power.” followed by a new line on
    the screen. Output is actually accomplished by the built-in method WriteLine( ). In this case,
    WriteLine( ) displays the string that is passed to it. Information that is passed to a method
    is called an argument. In addition to strings, WriteLine( ) can be used to display other types
    of information, such as numeric data. The line begins with Console, which is the name of a
    predefined class that supports console I/O. By connecting Console with WriteLine( ), you are
    telling the compiler that WriteLine( ) is a member of the Console class. The fact that C# uses
    an object to define console output is further evidence of its object-oriented nature.
    Notice that the WriteLine( ) statement ends with a semicolon, as does the using System
    statement earlier in the program. In general, all statements in C# end with a semicolon. The
    exception to this rule is the block, which begins with { and ends with }. A block does not end
    with a semicolon. This is why lines ending with } are not followed by a semicolon. Blocks
    provide a mechanism for grouping statements. They are examined in detail later in this chapter.
    The first } in the program ends Main( ), and the last } ends the Example class definition.

    ---------- Post added at 08:40 PM ---------- Previous post was at 08:39 PM ----------

    One last point: C# is case-sensitive. Forgetting this can cause serious problems. For
    example, if you accidentally type main instead of Main, or writeline instead of WriteLine,
    the preceding program will be incorrect. Furthermore, although the C# compiler will compile
    classes that do not contain a Main( ) method, there is no way to use one as an entry point for
    executing your program. So, if you had mistyped Main, the compiler would still compile your
    program. However, you would also see an error message that states that Example.exe does not
    have an entry point defined.
    Handling Syntax Errors
    If you have not yet done so, enter, compile, and run the preceding program. As you may know
    from your previous programming experience, it is quite easy to accidentally type something
    incorrectly when entering code into your computer. If this happens, the compiler will report a
    syntax error when it tries to compile it. The message displayed will contain the line number and
    character position at which the error is found and a description of the error.
    Although the syntax errors reported by the compiler are, obviously, helpful, they are also
    sometimes misleading. The C# compiler attempts to make sense out of your source code no
    matter what you have written. For this reason, the error that is reported may not always reflect

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  6. #6 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    the actual cause of the problem. In the preceding program, for example, an accidental omission
    of the ****ing curly brace after the Main( ) method generates the following sequence of
    errors when compiled by the csc command-line compiler (Similar errors are generated when
    compiling using the IDE.):
    EX1.CS(12,21): error CS1002: ; expected
    EX1.CS(13,22): error CS1519: Invalid token '(' in class, struct, or
    interface member declaration
    EX1.CS(15,1): error CS1022: Type or namespace definition, or
    end-of-file expected
    Clearly, the first error message is completely wrong, because what is missing is not a semicolon,
    but a curly brace. The second two messages are equally confusing.
    The point of this discussion is that when your program contains a syntax error, don’t
    necessarily take the compiler’s messages at face value. They may be misleading. You may need
    to “second guess” an error message in order to find the problem. Also, look at the last few lines
    of code immediately preceding the one in which the error was reported. Sometimes an error will
    not be reported until several lines after the point at which the error really occurred.

    ---------- Post added at 08:41 PM ---------- Previous post was at 08:40 PM ----------

    A Small Variation
    Although all of the programs in this book will use it, the statement
    using System;
    at the start of the first example program is not technically needed. It is, however, a valuable
    convenience. The reason it’s not necessary is that in C# you can always fully qualify a name
    with the namespace to which it belongs. For example, the line
    Console.WriteLine("A simple C# program.");
    can be rewritten as
    System.Console.WriteLine("A simple C# program.");
    You will occasionally see C# code that uses this approach, but it’s not common. Most C#
    programmers include the using System statement at the top of their programs, as do all of the
    programs in this book. Doing so avoids the tedium of always having to specify the System
    namespace whenever a member of that namespace is used. It is important to understand,
    however, that you can explicitly qualify a name with its namespace if needed.
    Using a Variable
    Perhaps no other construct is as important to a programming language as the variable. A variable
    is a named memory location that can be assigned a value. It is called a variable because its value
    can be changed during the execution of a program. In other words, the contents of a variable are
    changeable, not fixed.

    ---------- Post added at 08:42 PM ---------- Previous post was at 08:41 PM ----------

    Let’s begin with an example. The following program creates three variables called length,
    width, and area. It uses these variables to compute and display the area of a rectangle that has
    the dimensions 9 by 7.
    // This program introduces variables.
    using System;
    class UseVars {
    static void Main() {
    int length; // this declares a variable
    int width; // this declares another variable
    int area; // this is a third variable
    // Assign length the value 9.
    length = 9;
    // This displays the current value of length.
    Console.WriteLine("length contains " + length);
    // Assign width the value 7.
    width = 7;
    // This displays the current value of width.
    Console.WriteLine("width contains " + width);
    // Assign to area the product of length and width.
    area = length * width;
    // Display the result.
    Console.Write("area contains length * width: ");
    Console.WriteLine(area);
    }
    }

    ---------- Post added at 08:42 PM ---------- Previous post was at 08:42 PM ----------

    When you run this program, you will see the following output:
    length contains 9
    width contains 7
    area contains length * width: 63
    This program introduces several new concepts. First, the statement
    int length; // this declares a variable
    declares a variable called length of type integer. In C#, all variables must be declared before
    they are used. Further, the kind of values that the variable can hold must also be specified.
    This is called the type of the variable. In this case, length can hold integer values. These are
    whole numbers. In C#, to declare a variable to be of type integer, precede its name with the
    keyword int. Thus, the preceding statement declares a variable called length of type int.
    The next two lines declare two more int variables, called width and area:
    int width; // this declares another variable
    int area; // this is a third variable
    Notice that each uses the same format as the first, except that the name of the variable is
    different.
    In general, to declare a variable, you will use a statement like this:
    type var-name;
    Here, type specifies the type of variable being declared, and var-name is the name of the
    variable. In addition to int, C# supports several other data types, such as double, char, and
    string.
    The following line of code assigns length the value 9:
    length = 9;

    ---------- Post added at 08:43 PM ---------- Previous post was at 08:42 PM ----------

    In C#, the assignment operator is the single equal sign. It copies the value on its right side into
    the variable on its left.
    The next line of code outputs the value of length preceded by the string “length contains.”
    Console.WriteLine("length contains " + length);
    In this statement, the plus sign causes the value of length to be displayed after the string that
    precedes it. This approach can be generalized. Using the + operator, you can chain together as
    many items as you want within a single WriteLine( ) statement.
    Next, the value of width is set to 7 and displayed, using the same type of statements just
    described. Then, the following line of code assigns area the value of length times width.
    area = length * width;
    This line multiplies the value in length (which is 9) by the value in width (which is 7), and
    then stores that result in area. Thus, after the line executes, area will contain the value 63. The
    values of length and width will be unchanged.
    Like most other computer languages, C# supports a complete set of arithmetic operators,
    including those shown here:
    + Addition
    − Subtraction
    * Multiplication
    / Division
    These can be used with any type of numeric data

    ---------- Post added at 08:44 PM ---------- Previous post was at 08:43 PM ----------

    Q: You say that all variables must be declared before they are used, and that all variables
    have a type. However, you mention that C# 3.0 includes a new feature called an implicitly
    typed variable. What is this, and does it circumvent the need to declare variables?
    A: As you will learn in Chapter 2, implicitly typed variables are variables whose type is
    automatically determined by the compiler. Understand, however, that an implicitly typed
    variable still needs to be declared. Instead of using a type name, such as int, an implicitly
    typed variable is declared using the var keyword. Implicitly typed variables are very
    useful in several specialized situations (especially those involving LINQ), but they are not
    intended to replace explicitly typed variables in general. Normally, when you declare a
    variable, you give it an explicit type.

    ---------- Post added at 08:44 PM ---------- Previous post was at 08:44 PM ----------

    Here are the next two lines in the program:
    Console.Write("area contains length * width: ");
    Console.WriteLine(area);
    Two new things are occurring here. First, the built-in method Write( ) is used to display the
    string “area contains length * width:”. This string is not followed by a new line. This means
    that when the next output is generated, it will start on the same line. The Write( ) method is just
    like WriteLine( ), except that it does not output a new line after each call. Second, in the call to
    WriteLine( ), notice that area is used by itself. Both Write( ) and WriteLine( ) can be used to
    output values of any of C#’s built-in types.
    One more point about declaring variables before we move on: It is possible to declare two
    or more variables using the same declaration statement. Just separate their names by commas.
    For example, length and width could have been declared like this:
    int length, width; // both length and width declared using one statement
    The double Data Type
    In the preceding program, a variable of type int was used. However, a variable of type int can
    hold only whole numbers. Thus, it cannot be used when a fractional component is required. For
    example, an int variable can hold the value 18, but not the value 18.3. Fortunately, int is only
    one of several data types defined by C#. To allow numbers with fractional components, C#
    defines two floating-point types: float and double, which represent single- and double-precision
    values, respectively. Of the two, double is the most commonly used.
    To declare a variable of type double, use a statement similar to that shown here:
    double result;

    ---------- Post added at 08:45 PM ---------- Previous post was at 08:44 PM ----------

    Here, result is the name of the variable, which is of type double. Because result has a floatingpoint
    type, it can hold values such as 122.23, 0.034, and –19.0.
    To better understand the difference between int and double, try the following program:
    /*
    This program illustrates the differences
    between int and double.
    */
    using System;
    class IntVsDouble {
    static void Main() {
    int ivar; // this declares an int variable
    double dvar; // this declares a floating-point variable
    // Assign ivar the value 10.
    ivar = 10;
    // Assign dvar the value 10.0.
    dvar = 10.0;
    Console.WriteLine("Original value of ivar: " + ivar);
    Console.WriteLine("Original value of dvar: " + dvar);

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  7. #7 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    Console.WriteLine(); // print a blank line
    // Now, divide both by 4.
    ivar = ivar / 4;
    dvar = dvar / 4.0;
    Console.WriteLine("ivar after division: " + ivar);
    Console.WriteLine("dvar after division: " + dvar);
    }
    }
    The output from this program is shown here:
    Original value of ivar: 10
    Original value of dvar: 10
    ivar after division: 2
    dvar after division: 2.5
    As you can see, when ivar is divided by 4, a whole-number division is performed and the
    outcome is 2—the fractional component is lost. However, when dvar is divided by 4.0, the
    fractional component is preserved and the outcome is 2.5.

    ---------- Post added at 08:47 PM ---------- Previous post was at 08:46 PM ----------

    Q: Why does C# have different data types for integers and floating-point values? That is,
    why aren’t all numeric values just the same type?
    A: C# supplies different data types so that you can write efficient programs. For example,
    integer arithmetic is faster than floating-point calculations. Thus, if you don’t need
    fractional values, you don’t need to incur the overhead associated with types float or
    double. Secondly, the amount of memory required for one type of data might be less than
    that required for another. By supplying different types, C# enables you to make the best
    use of system resources. Finally, some algorithms require (or at least benefit from) the use
    of a specific type of data. C# supplies a number of built-in types to give you the greatest
    flexibility.

    ---------- Post added at 08:48 PM ---------- Previous post was at 08:47 PM ----------

    As the program shows, when you want to specify a floating-point value in a program, it
    must include a decimal point. If you don’t, it will be interpreted as an integer. For example, in
    C#, the value 100 is an integer, but the value 100.0 is a floating-point value.
    There is one other new thing to notice in the program. To print a blank line, simply call
    WriteLine( ) without any arguments.
    Convert Fahrenheit to Celsius
    Although the preceding sample programs illustrate several important features of the C#
    language, they are not very useful. Even though you do not know much about C# at this point,
    you can still put what you have learned to work to create a practical program. Here you will
    create a program that converts Fahrenheit to Celsius.
    The program declares two double variables. One will hold the number of the degrees in
    Fahrenheit, and the second will hold the number of degrees in Celsius after the conversion. The
    formula for converting Fahrenheit to Celsius is
    C = 5/9 * (F – 32)
    where C is the temperature in degrees Celsius and F is the temperature in degrees Fahrenheit.
    Step by Step
    1. Create a new C# file called FtoC.cs. (If you are using the Visual Studio IDE rather than the
    command-line compiler, you will need to add this file to a C# project, as described earlier.)
    2. Enter the following program into the file:
    /*
    This program converts Fahrenheit to Celsius.

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  8. #8 Collapse post
    maha elsayed is offline
    خبير فوركس مصر Array
    Join Date
    Aug 2013
    Posts
    9,887
    Accrued Payments
    1228 USD
    Thanks
    0
    Thanked 72 Times in 60 Posts
    SubscribeSubscribe
    subscribed 0
    السلام عليكم ورحمه الله وبركاته اشكرك يا اخى ع هذا الكتاب الرائع
    تقبل مرورى ارجوك واكيد هقراه

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  9. #9 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    Call this program FtoC.cs.
    */
    using System;
    class FtoC {
    static void Main() {
    double f; // holds the temperature in Fahrenheit
    double c; // holds the temperature in Celsius
    // Begin with 59 degrees Fahrenheit
    f = 59.0;
    // convert to Celsius
    c = 5.0 / 9.0 * (f - 32.0);
    Console.Write(f + " degrees Fahrenheit is ");
    Console.WriteLine(c + " degrees Celsius.");
    }
    }
    3. Compile the program using the Visual Studio IDE (using the instructions shown earlier in
    this chapter) or by using the following command line:
    C>csc FtoC.cs
    4. Run the program. You will see this output:
    59 degrees Fahrenheit is 15 degrees Celsius.
    5. As it stands, this program converts 59 degrees Fahrenheit to Celsius. However, by changing
    the value assigned to f, you can have the program convert a different temperature. Notice that
    the variables f and c are of type double. This is necessary because the fractional component
    of the operations is needed to ensure an accurate conversion.

    ---------- Post added at 08:50 PM ---------- Previous post was at 08:49 PM ----------

    Two Control Statements
    Inside a method, execution proceeds from one statement to the next, top to bottom. However, it
    is possible to alter this flow through the use of the various program control statements supported
    by C#. Although we will look closely at control statements in Chapter 3, two are briefly
    introduced here because we will be using them to write sample programs.
    The if Statement
    You can selectively execute part of a program through the use of C#’s conditional statement: the
    if. The if statement works in C# much like the IF statement in any other language. For example,

    ---------- Post added at 08:51 PM ---------- Previous post was at 08:50 PM ----------

    it is syntactically similar to the if statements in C, C++, and Java. Its simplest form is shown
    here:
    if(condition) statement;
    Here, condition is a Boolean (that is, true or false) expression. If condition is true, then the
    statement is executed. If condition is false, then the statement is bypassed. Here is an example:
    if(10 < 11) Console.WriteLine("10 is less than 11");
    In this case, since 10 is less than 11, the conditional expression is true, and WriteLine( ) will
    execute. However, consider the following:
    if(10 < 9) Console.WriteLine("this won't be displayed");
    In this case, 10 is not less than 9. Thus, the call to WriteLine( ) will not take place.
    C# defines a full complement of relational operators that can be used in a conditional
    expression. They are shown here:

    ---------- Post added at 08:52 PM ---------- Previous post was at 08:51 PM ----------

    Operator Meaning
    < Less than
    <= Less than or equal to
    > Greater than
    >= Greater than or equal to
    = = Equal to
    != Not equal to
    Notice that the test for equality is the double equal sign.
    Here is a program that illustrates the if statement and the relational operators.
    // Demonstrate the if.
    using System;
    class IfDemo {
    static void Main() {
    int a, b, c;
    a = 2;
    b = 3;
    // This if statement succeeds because a is less than b.
    if(a < b) Console.WriteLine("a is less than b");
    The WriteLine( ) statement is executed
    only when the condition is true.
    This is the condition tested by the if.

    ---------- Post added at 08:52 PM ---------- Previous post was at 08:52 PM ----------

    The output generated by this program is shown here:
    a is less than b
    a contains the value 2
    a equals b - 1
    c contains -1
    c is negative
    c now contains 1
    c is non-negative
    Notice one other thing in this program. The line
    int a, b, c;

    ---------- Post added at 08:53 PM ---------- Previous post was at 08:52 PM ----------

    declares three variables, a, b, and c, by use of a comma-separated list. As mentioned earlier,
    when you need two or more variables of the same type, they can be declared in one statement.
    Just separate the variable names by commas.
    The for Loop
    You can repeatedly execute a sequence of code by creating a loop. C# supplies a powerful
    assortment of loop constructs. The one we will look at here is the for loop. If you are familiar
    with C, C++, or Java, you will be pleased to know that the for loop in C# works the same way it
    does in those languages. The simplest form of the for loop is shown here:
    for(initialization; condition; iteration) statement;
    In its most common form, the initialization portion of the loop sets a loop control variable
    to an initial value. The condition is a Boolean expression that tests the loop control variable.
    If the outcome of that test is true, the for loop continues to iterate. If it is false, the loop
    terminates. The iteration expression determines how the loop control variable is changed each
    time the loop iterates. Here is a short program that illustrates the for loop:
    // Demonstrate the for loop.

    ---------- Post added at 08:54 PM ---------- Previous post was at 08:53 PM ----------

    using System;
    class ForDemo {
    static void Main() {
    int count;
    Console.WriteLine("Counting from 0 to 4:");
    for(count = 0; count < 5; count = count+1)
    Console.WriteLine(" count is " + count);
    Console.WriteLine("Done!");
    }
    }
    The output generated by the program is shown here:
    Counting from 0 to 4:
    count is 0
    count is 1
    count is 2
    count is 3
    count is 4
    Done!
    In this example, count is the loop control variable. It is set to zero in the initialization portion
    of the for. At the start of each iteration (including the first one), the conditional test count < 5 is
    performed. If the outcome of this test is true, the WriteLine( ) statement is executed, and then

    ---------- Post added at 08:57 PM ---------- Previous post was at 08:54 PM ----------

    the iteration portion of the loop is executed. This process continues until the conditional test is
    false, at which point execution picks up at the bottom of the loop.
    As a point of interest, in professionally written C# programs, you will almost never see the
    iteration portion of the loop written as shown in the preceding program. That is, you will seldom
    see statements like this:
    count = count + 1;
    The reason is that C# includes a special increment operator that performs this operation more
    compactly. The increment operator is ++ (two consecutive plus signs). The increment operator
    increases its operand by one. By use of the increment operator, the preceding statement can be
    written like this:
    count++;
    Thus, the for in the preceding program will usually be written like this:
    for(count = 0; count < 5; count++)
    You might want to try this. As you will see, the loop still runs exactly the same as it did before.
    C# also provides a decrement operator, which is specified as – – (two consecutive minus
    signs). This operator decreases its operand by one.

    ---------- Post added at 08:57 PM ---------- Previous post was at 08:57 PM ----------

    Using Blocks of Code
    Another key element of C# is the code block. A code block is a grouping of statements. A code
    block is created by enclosing the statements between ****ing and closing curly braces. Once a
    block of code has been created, it becomes a logical unit that can be used any place that a single
    statement can. For example, a block can be a target for if and for statements. Consider this if
    statement:
    if(counter < max) {
    usercount = counter;
    delaytime = 0;
    }
    Here, if counter is less than max, both statements inside the block will be executed. Thus, the
    two statements inside the block form a logical unit, and one statement cannot execute without
    the other also executing. The key point here is that whenever you need to logically link two
    or more statements, you do so by creating a block. Code blocks allow many algorithms to be
    implemented with greater clarity and efficiency.
    Here is a program that uses a block of code to prevent a division by zero:
    // Demonstrate a block of code.

    ---------- Post added at 08:58 PM ---------- Previous post was at 08:57 PM ----------

    class BlockDemo {
    static void Main() {
    double i, j, d;
    i = 5.0;
    j = 10.0;
    // The target of this if is a block.
    if(i != 0) {
    Console.WriteLine("i does not equal zero");
    d = j / i;
    Console.WriteLine("j / i is " + d);
    }
    }
    }
    The output generated by this program is shown here:
    i does not equal zero
    j / i is 2
    In this case, the target of the if statement is a block of code and not just a single statement. If the
    condition controlling the if is true (as it is in this case), the three statements inside the block will
    be executed. Try setting i to zero and observe the result.
    As you will see later in this book, blocks of code have additional properties and uses.
    However, the main reason for their existence is to create logically inseparable units of code.

    ---------- Post added at 08:59 PM ---------- Previous post was at 08:58 PM ----------

    Semicolons and Positioning
    In C#, the semicolon signals the end of a statement. That is, each individual statement must end
    with a semicolon.
    As you know, a block is a set of logically connected statements that are surrounded by
    ****ing and closing braces. A block is not terminated with a semicolon. Since a block is a group
    of statements, it makes sense that a block is not terminated by a semicolon; instead, the end of
    the block is indicated by the closing brace.
    Q: Does the use of a code block introduce any runtime inefficiencies? In other words, do
    the { and } consume any extra time during the execution of my program?
    A: No. Code blocks do not add any overhead whatsoever. In fact, because of their ability to
    simplify the coding of certain algorithms, their use generally increases speed and efficiency.

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  10. #10 Collapse post
    zied toumi is offline
    Banned Array
    Join Date
    Oct 2013
    Posts
    78
    Accrued Payments
    6 USD
    Thanks
    0
    Thanked 1 Time in 1 Post
    C# does not recognize the end of the line as the end of a statement—only a semicolon
    terminates a statement. For this reason, it does not matter where on a line you put a statement.
    For example, to C#,
    x = y;
    y = y + 1;
    Console.WriteLine(x + " " + y);
    is the same as
    x = y; y = y + 1; Console.WriteLine(x + " " + y);
    Furthermore, the individual elements of a statement can also be put on separate lines. For
    example, the following is perfectly acceptable:
    Console.WriteLine("This is a long line of output" +
    x + y + z +
    "more output");
    Breaking long lines in this fashion is often used to make programs more readable. It can also
    help prevent excessively long lines from wrapping.

    ---------- Post added at 09:00 PM ---------- Previous post was at 08:59 PM ----------

    Indentation Practices
    You may have noticed in the previous examples that certain statements were indented. C#
    is a free-form language, meaning that it does not matter where you place statements relative
    to each other on a line. However, over the years, a common and accepted indentation style
    has developed that allows for very readable programs. This book follows that style, and it is
    recommended that you do so as well. Using this style, you indent one level after each ****ing
    brace, and move back out one level after each closing brace. There are certain statements that
    encourage some additional indenting; these will be covered later.
    Improve the Temperature Conversion Program
    You can use the for loop, the if statement, and code blocks to create an improved version of the
    Fahrenheit-to-Celsius converter that you developed in the first Try This example. This new version
    will print a table of conversions, beginning with 0 degrees Fahrenheit and ending with 99. After
    every 10 degrees, a blank line will be output. This is accomplished through the use of a variable
    called counter that counts the number of lines that have been output. *** special attention to its use.

    ---------- Post added at 09:01 PM ---------- Previous post was at 09:00 PM ----------

    Step by Step
    1. Create a new file called FtoCTable.cs.
    2. Enter the following program into the file:
    /*
    This program displays a conversion
    table of Fahrenheit to Celsius.
    Call this program FtoCTable.cs.
    */
    using System;
    class FtoCTable {
    static void Main() {
    double f, c;
    int counter;
    counter = 0;
    for(f = 0.0; f < 100.0; f++) {
    // Convert to Celsius
    c = 5.0 / 9.0 * (f - 32.0);
    Console.WriteLine(f + " degrees Fahrenheit is " +
    c + " degrees Celsius.");
    counter++;
    // Every 10th line, print a blank line.
    if(counter == 10) {
    Console.WriteLine();
    counter = 0; // reset the line counter
    }
    }
    }
    }
    3. Compile the program as described earlier.
    4. Run the program. Here is a portion of the output that you will see. Notice how a blank line
    is output every tenth line. As mentioned, this is controlled by the counter variable, which is
    initially set to zero. Each time through the for loop, counter is incremented. When counter
    equals 10, a blank line is output and then counter is reset to zero. This process causes the
    output to be grouped into lines of ten units.
    0 degrees Fahrenheit is -17.7777777777778 degrees Celsius.
    1 degrees Fahrenheit is -17.2222222222222 degrees Celsius.

    ---------- Post added at 09:02 PM ---------- Previous post was at 09:01 PM ----------

    2 degrees Fahrenheit is -16.6666666666667 degrees Celsius.
    3 degrees Fahrenheit is -16.1111111111111 degrees Celsius.
    4 degrees Fahrenheit is -15.5555555555556 degrees Celsius.
    5 degrees Fahrenheit is -15 degrees Celsius.
    6 degrees Fahrenheit is -14.4444444444444 degrees Celsius.
    7 degrees Fahrenheit is -13.8888888888889 degrees Celsius.
    8 degrees Fahrenheit is -13.3333333333333 degrees Celsius.
    9 degrees Fahrenheit is -12.7777777777778 degrees Celsius.
    10 degrees Fahrenheit is -12.2222222222222 degrees Celsius.
    11 degrees Fahrenheit is -11.6666666666667 degrees Celsius.
    12 degrees Fahrenheit is -11.1111111111111 degrees Celsius.
    13 degrees Fahrenheit is -10.5555555555556 degrees Celsius.
    14 degrees Fahrenheit is -10 degrees Celsius.
    15 degrees Fahrenheit is -9.44444444444444 degrees Celsius.
    16 degrees Fahrenheit is -8.88888888888889 degrees Celsius.
    17 degrees Fahrenheit is -8.33333333333333 degrees Celsius.
    18 degrees Fahrenheit is -7.77777777777778 degrees Celsius.
    19 degrees Fahrenheit is -7.22222222222222 degrees Celsius.

    ---------- Post added at 09:02 PM ---------- Previous post was at 09:02 PM ----------

    The C# Keywords
    At its foundation, a computer language is defined by its keywords, and C# provides a rich and
    diverse set. Furthermore, C# defines two general types of keywords: reserved and contextual.
    The reserved keywords cannot be used as names for variables, classes, or methods. They can
    be used only as keywords. This is why they are called reserved. The terms reserved words or
    reserved identifiers are also sometimes used. There are currently 77 reserved keywords defined
    by version 3.0 of the C# language. They are shown in Table 1-1.
    C# 3.0 defines 13 contextual keywords that have a special meaning in certain contexts. In
    those contexts, they act as keywords. Outside their context, they can be used as names for other
    program elements, such as variable names. Thus, they are not technically reserved. As a general
    rule, however, you should consider the contextual keywords reserved and avoid using them for
    any other purpose. Using a contextual keyword as a name for some other program element can
    be confusing and is considered bad practice by many programmers. The contextual keywords
    are shown in Table 1-2.
    Identifiers
    In C#, an identifier is a name assigned to a method, a variable, or any other user-defined item.
    Identifiers can be from one to several characters long. Variable names may start with any
    letter of the alphabet or with an underscore. Next may be a letter, a digit, or an underscore.
    The underscore can be used to enhance the readability of a variable name, as in line_count.

    ---------- Post added at 09:03 PM ---------- Previous post was at 09:02 PM ----------

    Uppercase and lowercase are different; that is, to C#, myvar and MyVar are separate names.
    Here are some examples of acceptable identifiers:
    Test x y2 MaxLoad
    up _top my_var sample23
    Remember that you can’t start an identifier with a digit. Thus, 12x is invalid, for example.
    Good programming practice dictates that you use identifier names that reflect the meaning or
    usage of the items being named.
    Although you cannot use any of the C# keywords as identifiers, C# does allow you to precede
    a keyword with an @, allowing it to be a legal identifier. For example, @for is a valid identifier. In
    this case, the identifier is actually for and the @ is ignored. Frankly, using @-qualified keywords
    for identifiers is not recommended, except for special purposes. Also, the @ can precede any
    identifier, but this is considered bad practice.

    ---------- Post added at 09:05 PM ---------- Previous post was at 09:03 PM ----------

    The C# Class Library
    The sample programs shown in this chapter make use of two of C#’s built-in methods:
    WriteLine( ) and Write( ). As mentioned, these methods are members of the Console class,
    which is part of the System namespace, which is defined by the .NET Framework’s class
    library. As explained earlier in this chapter, the C# environment relies on the .NET Framework
    class library to provide support for such things as I/O, string handling, networking, and GUIs.
    Thus, C# as a totality is a combination of the C# language itself, plus the .NET standard
    classes. As you will see, the class library provides much of the functionality that is part of any
    C# program. Indeed, part of becoming a C# programmer is learning to use the standard library.
    Throughout this book, various elements of the .NET library classes and methods are described.
    However, the .NET library is quite large, and it is something you will also want to explore
    more on your own.
    Chapter 1 Self Test
    1. What is the MSIL and why is it important to C#?
    2. What is the Common Language Runtime?
    3. What are the three main principles of object-oriented programming?
    4. Where do C# programs begin execution?
    5. What is a variable? What is a namespace?
    6. Which of the following variable names is invalid?
    A. count
    B. $count
    C. count27
    D. 67count
    E. @if
    7. How do you create a single-line comment? How do you create a multiline comment?
    8. Show the general form of the if statement. Show the general form of the for loop.
    9. How do you create a block of code?
    10. Is it necessary to start each C# program with the following statement?
    using System;
    11. The moon’s gravity is about 17 percent that of Earth’s. Write a program that computes your
    effective weight on the moon.
    12. Adapt the FtoCTable program in “Try This: Improve the Temperature Conversion Program”
    so that it prints a conversion table of inches to meters. Display 12 feet of conversions, inch by
    inch. Output a blank line every 12 inches. (One meter equals approximately 39.37 inches.)

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


+ Reply to Thread
Page 1 of 7 1 2 3 ...

Subscribe to this Thread (2)

Tags for this Thread

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts

Threads

Posts

Members