Docstoc

Documentation

Document Sample
Documentation Powered By Docstoc
					TEXT TO SPEECH




[Type the abstract of the document here.
The abstract is typically a short summary of
the contents of the document. Type the
abstract of the document here. The
abstract is typically a short summary of the
contents of the document.]

                                                                    TEXT TO SPEECH

                                                                Table of Contents
ACKNOWLEDGEMENTS ................................................................................................................................................3
   ACKNOWLEDGEMENTS ............................................................................................................................................4
Abstract .....................................................................................................................................................................5
Abstract .....................................................................................................................................................................6
Introduction about project ...........................................................................................................................................7
Introduction about project ...........................................................................................................................................8
Introduction about S.W & H.W ................................................................................................................................... 15
Microsoft Visual Studio .............................................................................................................................................. 17
   Architecture .......................................................................................................................................................... 18
      Code editor ........................................................................................................................................................ 20
      Debugger ........................................................................................................................................................... 22
      Designer ............................................................................................................................................................ 23
      Other tools ......................................................................................................................................................... 25
      Extensibility ....................................................................................................................................................... 28
   Supported products ................................................................................................................................................ 30
      Included products ............................................................................................................................................... 30
      Previous products ............................................................................................................................................... 33
   Editions ................................................................................................................................................................ 34
      Visual Studio Express .......................................................................................................................................... 35
Visual studio c# ........................................................................................................................................................ 37
   Design goals ........................................................................................................................................................... 37
   History .................................................................................................................................................................. 39
   Syntax ................................................................................................................................................................... 41
      Distinguishing features ....................................................................................................................................... 42
   Common type system ............................................................................................................................................ 44
      Categories of data types ..................................................................................................................................... 45
      Boxing and unboxing .......................................................................................................................................... 46
      Generics ............................................................................................................................................................ 46
   Preprocessor ......................................................................................................................................................... 47
   Code comments ..................................................................................................................................................... 47
   XML documentation system .................................................................................................................................... 47
   Libraries ................................................................................................................................................................ 48
   Standardization and licensing ................................................................................................................................. 48
   Implementations ...................................................................................................................................................... 50
Project objectives ...................................................................................................................................................... 52



                                                                                                                                             1
                                                                   TEXT TO SPEECH
   Project objectives .................................................................................................................................................. 53
Survey about project ................................................................................................................................................. 54
   Survey about project.............................................................................................................................................. 55
Project analysis ......................................................................................................................................................... 60
   Use cases .............................................................................................................................................................. 61
   Use Case Diagram: ................................................................................................................................................ 62
   Sequence diagram ................................................................................................................................................. 69
Implementation ........................................................................................................................................................ 78
   User interface:....................................................................................................................................................... 79
   Program coding: .................................................................................................................................................... 80
Conclusion .............................................................................................................................................................. 145
(References) ........................................................................................................................................................... 147




                                                                                                                                           2
     TEXT TO SPEECH




        (A)
ACKNOWLEDGEMENTS




                      3
                   TEXT TO SPEECH




ACKNOWLEDGEMENTS


The satisfaction that accompanies that the successful
completion of any task.
Would be incomplete without the mention of people
whose Cooperation made it possible, whose constant
guidance and encouragement Crown all efforts with
success.
We are grateful to our project guide DR/ Mohammed
Marie for the guidance,
Inspiration and constructive suggestions that helpful
us in the preparation of This project.
We also thank our colleagues who have helped in
successful completion of The project.




                                          4
 TEXT TO SPEECH




    (B)
Abstract




                  5
                          TEXT TO SPEECH




Abstract
I try to give here a short but comprehensive introduction to state-of-
the-art Text-To-Speech (TTS) synthesis by highlighting its Digital
Signal Processing (DSP) and Natural Language Processing (NLP)
components. As a matter of fact, since very few people associate a
good knowledge of DSP with a comprehensive insight into NLP,
synthesis mostly remains unclear, even for people working in either
research area.
After a brief definition of a general TTS system and of its
commercial applications, in Section 1, the paper is basically divided
into two parts. Section 2.1 begins with a presentation of the many
practical NLP problems which have to be solved by a TTS system.
 I then examine, in Section 2.2, how synthetic speech can be
obtained by simply concatenating elementary speech units, and what
choices have to be made for this operation to yield high quality.
I finally give a word on existing TTS solutions, with special
emphasis on the computational and economical constraints which
have to be kept in mind when designing TTS systems.




                                                        6
      TEXT TO SPEECH




  Chapter (1.1)

Introduction about
      project



                       7
                        TEXT TO SPEECH



Introduction about project

A Text-To-Speech (TTS) synthesizer is a computer-based system
that should be able to read any text aloud, whether it was directly
introduced in the computer by an operator or scanned and submitted
to an Optical Character Recognition (OCR) system. Let us try to be
clear. There is a fundamental difference between the system we are
about to discuss here and any other talking machine (as a cassette-
player for example) in the sense that we are interested in the
automatic production of new sentences. This definition still needs
some refinements. Systems that simply concatenate isolated words
or parts of sentences, denoted as Voice Response Systems, are only
applicable when a limited vocabulary is required (typically a few
one hundreds of words), and when the sentences to be pronounced
respect a very restricted structure, as is the case for the
announcement of arrivals in train stations for instance. In the
context of TTS synthesis, it is impossible (and luckily useless) to
record and store all the words of the language. It is thus more
suitable to define Text-To-Speech as the automatic production of
speech, through a grapheme-to-phoneme transcription of the
sentences to utter.
At first sight, this task does not look too hard to perform. After
all, is not the human being potentially able to correctly
pronounce an unknown sentence, even from his childhood? We
all have, mainly unconsciously, a deep knowledge of the reading
rules of our mother tongue. They were transmitted to us, in a

                                                     8
                         TEXT TO SPEECH

simplified form, at primary school, and we improved them year
after year. However, it would be a bold claim indeed to say that
it is only a short step before the computer is likely to equal the
human being in that respect. Despite the present state of our
knowledge and techniques and the progress recently
accomplished in the fields of Signal Processing and Artificial
Intelligence, we would have to express some reservations. As a
matter of fact, the reading process draws from the furthest
depths, often unsought of, of the human intelligence.
Automatic Reading: what for?

Each and every synthesizer is the result of a particular and
original imitation of the human reading capability, submitted to
technological and imaginative constraints that are characteristic
of the time of its creation. The concept of high quality TTS
synthesis appeared in the mid-eighties, as a result of important
developments in speech synthesis and natural language
processing techniques, mostly due to the emergence of new
technologies (Digital Signal and Logical Inference Processors).
It is now a must for the speech products family expansion.
Potential applications of High Quality TTS Systems are indeed
numerous. Here are some examples:
Telecommunications services. TTS systems make it possible to
access textual information over the telephone. Knowing that
about 70 % of the telephone calls actually require very little
interactivity, such a prospect is worth being considered. Texts

                                                     9
                        TEXT TO SPEECH

might range from simple messages, such as local cultural events
not to miss (cinemas, theatres....,), to huge databases which can
hardly be read and stored as digitized speech. Queries to such
information retrieval systems could be put through the user's
voice (with the help of a speech recognizer), or through the
telephone keyboard (with DTMF systems). One could even
imagine that our (artificially) intelligent machines could speed
up the query when needed, by providing lists of keywords, or
even summaries. In this connection, AT&T has recently
organized a series of consumer tests for some promising
telephone services [Levinson et al. 93]. They include: Who's
Calling (get the spoken name of your caller before being
connected and hang up to avoid the call), Integrated Messaging
(have your electronic mail or facsimiles being automatically read
over the telephone), Telephone Relay Service (have a telephone
conversation with speech or hearing impaired persons thanks to
ad hoc text-to-voice and voice-to-text conversion), and
Automated Caller Name and Address (a computerized version of
the "reverse directory"). These applications have proved
acceptable, and even popular, provided the intelligibility of the
synthetic utterances was high enough. Naturalness was not a
major issue in most cases.
Language education. High Quality TTS synthesis can be coupled
with a Computer Aided Learning system, and provide a helpful
tool to learn a new language. To our knowledge, this has not
been done yet, given the relatively poor quality available with


                                                   10
                        TEXT TO SPEECH

commercial systems, as opposed to the critical requirements of
such tasks.
Aid to handicapped persons. Voice handicaps originate in mental
or motor/sensation disorders. Machines can be an invaluable
support in the latter case: with the help of an especially designed
keyboard and a fast sentence assembling program, synthetic
speech can be produced in a few seconds to remedy these
impediments. Astro-physician Stephen Hawking gives all his
lectures in this way. The aforementioned Telephone Relay
Service is another example. Blind people also widely benefit
from TTS systems, when coupled with Optical Recognition
Systems (OCR), which give them access to written information.
The market for speech synthesis for blind users of personal
computers will soon be invaded by mass-market synthesizers
bundled with sound cards. DEC talk (TM) is already available
with the latest SoundBlaster (TM) cards now, although not yet in
a form useful for blind people.
Talking books and toys. The toy market has already been
touched by speech synthesis. Many speaking toys have appeared,
under the impulse of the innovative 'Magic Spell' from Texas
Instruments. The poor quality available inevitably restrains the
educational ambition of such products. High Quality synthesis at
affordable prices might well change this.
Vocal Monitoring. In some cases, oral information is more
efficient than written messages. The appeal is stronger, while the
attention may still focus on other visual sources of information.
                                                    11
                        TEXT TO SPEECH

Hence the idea of incorporating speech synthesizers in
measurement or control systems.
Multimedia, man-machine communication. In the long run, the
development of high quality TTS systems is a necessary step (as
is the enhancement of speech recognizers) towards more
complete means of communication between men and computers.
Multimedia is a first but promising move in this direction.
Fundamental and applied research. TTS synthesizers possess a
very peculiar feature which makes them wonderful laboratory
tools for linguists: they are completely under control, so that
repeated experiences provide identical results (as is hardly the
case with human beings). Consequently, they allow to
investigate the efficiency of into native and rhythmic models. A
particular type of TTS systems, which are based on a description
of the vocal tract through its resonant frequencies (its formants)
and denoted as formant synthesizers, has also been extensively
used by phoneticians to study speech in terms of acoustical rules.
In this manner, for instance, articulatory constraints have been
enlightened and formally described.
How does a machine read?

From now on, it should be clear that a reading machine would
hardly adopt a processing scheme as the one naturally taken up
by humans, whether it was for language analysis or for speech
production itself. Vocal sounds are inherently governed by the
partial differential equations of fluid mechanics, applied in a

                                                   12
                        TEXT TO SPEECH

dynamic case since our lung pressure, glottis tension, and vocal
and nasal tracts configuration evolve with time. These are
controlled by our cortex, which takes advantage of the power of
its parallel structure to extract the essence of the text read: its
meaning. Even though, in the current state of the engineering art,
building a Text-To-Speech synthesizer on such intricate models
is almost scientifically conceivable (intensive research on
articulatory synthesis, neural networks, and semantic analysis
give evidence of it), it would result anyway in a machine with a
very high degree of (possibly avoidable) complexity, which is
not always compatible with economical criteria. After all, flies
do not flap their wings!
Figure 1 introduces the functional diagram of a very general TTS
synthesizer. As for human reading, it comprises a Natural
Language Processing module (NLP), capable of producing a
phonetic transcription of the text read, together with the desired
intonation and rhythm (often termed as prosody), and a Digital
Signal Processing module (DSP), which transforms the symbolic
information it receives into speech. But the formalisms and
algorithms applied often manage, thanks to a judicious use of
mathematical and linguistic knowledge of developers, to short-
circuit certain processing steps. This is occasionally achieved at
the expense of some restrictions on the text to pronounce, or
results in some reduction of the "emotional dynamics" of the
synthetic voice (at least in comparison with human
performances), but it generally allows to solve the problem in
real time with limited memory requirements.

                                                    13
TEXT TO SPEECH




                 14
      TEXT TO SPEECH



  Chapter (1.2)


Introduction about
    S.W & H.W




                       15
TEXT TO SPEECH




(1.2.1)




                 16
                         TEXT TO SPEECH




Microsoft Visual Studio
Microsoft Visual Studio is an integrated development environment
(IDE) from Microsoft. It is used to develop console and graphical
user interface applications along with Windows Forms applications,
web sites, web applications, and web services in both native code
together with managed code for all platforms supported by
Microsoft Windows, Windows Mobile, Windows CE, .NET
Framework, .NET Compact Framework and Microsoft Silverlight.
Visual Studio includes a code editor supporting IntelliSense as well
as code refactoring. The integrated debugger works both as a
source-level debugger and a machine-level debugger. Other built-in
tools include a forms designer for building GUI applications, web
designer, class designer, and database schema designer. It accepts
plug-ins that enhance the functionality at almost every level—
including adding support for source-control systems (like
Subversion and Visual SourceSafe) and adding new toolsets like
editors and visual designers for domain-specific languages or
toolsets for other aspects of the software development lifecycle (like
the Team Foundation Server client: Team Explorer).
Visual Studio supports different programming languages by means
of language services, which allow the code editor and debugger to
support (to varying degrees) nearly any programming language,

                                                       17
                         TEXT TO SPEECH

provided a language-specific service exists. Built-in languages
include C/C++ (via Visual C++), VB.NET (via Visual Basic .NET),
C# (via Visual C#), and F# (as of Visual Studio 2010[4]). Support
for other languages such as M, Python, and Ruby among others is
available via language services installed separately. It also supports
XML/XSLT, HTML/XHTML, JavaScript and CSS. Individual
language-specific versions of Visual Studio also exist which provide
more limited language services to the user: Microsoft Visual Basic,
Visual J#, Visual C#, and Visual C++.
Microsoft provides "Express" editions of its Visual Studio 2010
components Visual Basic, Visual C#, Visual C++, and Visual Web
Developer at no cost. Visual Studio 2010, 2008 and 2005
Professional Editions, along with language-specific versions (Visual
Basic, C++, C#, J#) of Visual Studio Express 2010 are available for
free to students as downloads via Microsoft's Dream Spark program.
Architecture
Visual Studio does not support any programming language, solution
or tool intrinsically, instead allows the plugging of functionality
coded as a VS Package. When installed, the functionality is
available as a Service. The IDE provides three services: SVs
Solution, which provides the ability to enumerate projects and
solutions; SVs UI Shell, which provides windowing and UI
functionality (including tabs, toolbars and tool windows); and SVs
Shell, which deals with registration of VS Packages. In addition, the
IDE is also responsible for coordinating and enabling
communication between services. All editors, designers, project
types and other tools are implemented as VS Packages. Visual

                                                       18
                         TEXT TO SPEECH

Studio uses COM to access the VS Packages. The Visual Studio
SDK also includes the Managed Package Framework (MPF), which
is a set of managed wrappers around the COM-interfaces that allow
the Packages to be written in any CLI compliant language.
However, MPF does not provide all the functionality exposed by the
Visual Studio COM interfaces. The services can then be consumed
for creation of other packages, which add functionality to the Visual
Studio IDE.
Support for programming languages is added by using a specific VS
Package called a Language Service. A language service defines
various interfaces which the VS Package implementation can
implement to add support for various functionalities Functionalities
that can be added this way include syntax coloring, statement
completion, brace matching, parameter information tooltips,
member lists and error markers for background compilation. If the
interface is implemented, the functionality will be available for the
language. Language services are to be implemented on a per-
language basis. The implementations can reuse code from the parser
or the compiler for the language. Language services can be
implemented either in native code or managed code. For native
code, either the native COM interfaces or the Babel Framework
(part of Visual Studio SDK) can be used. For managed code, the
MPF includes wrappers for writing managed language services.
Visual Studio does not include any source control support built in
but it defines two alternative ways for source control systems to
integrate with the IDE. A Source Control VS Package can provide
its own customised user interface. In contrast, a source control
plugin using the MSSCCI (Microsoft Source Code Control

                                                      19
                          TEXT TO SPEECH

Interface) provides a set of functions that are used to implement
various source control functionality, with a standard Visual Studio
user interface. MSSCCI was first used to integrate Visual
SourceSafe with Visual Studio 6.0 but was later opened up via the
Visual Studio SDK. Visual Studio .NET 2002 used MSSCCI 1.1,
and Visual Studio .NET 2003 used MSSCCI 1.2. Visual Studio
2005, 2008 and 2010 use MSSCCI Version 1.3, which adds support
for rename and delete propagation as well as asynchronous opening.
Visual Studio supports running multiple instances of the
environment (each with its own set of VS Packages). The instances
use different registry hives (see MSDN's definition of the term
"registry hive" in the sense used here) to store their configuration
state and are differentiated by their AppId (Application ID). The
instances are launched by an AppId-specific .exe that selects the
AppId, sets the root hive and launches the IDE. VS Packages
registered for one AppId are integrated with other VS Packages for
that AppId. The various product editions of Visual Studio are
created using the different AppIds. The Visual Studio Express
edition products are installed with their own AppIds, but the
Standard, Professional and Team Suite products share the same
AppId. Consequently, one can install the Express editions side-by-
side with other editions, unlike the other editions which update the
same installation. The professional edition includes a superset of the
VS Packages in the standard edition and the team suite includes a
superset of the VS.
Code editor

Visual Studio, like any other IDE, includes a code editor that
supports syntax highlighting and code completion using IntelliSense
                                                       20
                         TEXT TO SPEECH

for not only variables, functions and methods but also language
constructs like loops and queries. IntelliSense is supported for the
included languages, as well as for XML and for Cascading Style
Sheets and JavaScript when developing web sites and web
applications. Autocomplete suggestions are popped up in a
modeless list box, overlaid on top of the code editor. In Visual
Studio 2008 onwards, it can be made temporarily semi-transparent
to see the code obstructed by it. The code editor is used for all
supported languages.
The Visual Studio code editor also supports setting bookmarks in
code for quick navigation. Other navigational aids include
collapsing code blocks and incremental search, in addition to
normal text search and regex search. The code editor also includes a
multi-item clipboard and a task list. The code editor supports code
snippets, which are saved templates for repetitive code and can be
inserted into code and customized for the project being worked on.
A management tool for code snippets is built in as well. These tools
are surfaced as floating windows which can be set to automatically
hide when unused or docked to the side of the screen. The Visual
Studio code editor also supports code refactoring including
parameter reordering, variable and method renaming, interface
extraction and encapsulation of class members inside properties,
among others.
Visual Studio features background compilation (also called
incremental compilation). As code is being written, Visual Studio
compiles it in the background in order to provide feedback about
syntax and compilation errors, which are flagged with a red wavy
underline. Warnings are marked with a green underline.

                                                       21
                           TEXT TO SPEECH

Background compilation does not generate executable code, since it
requires a different compiler than the one used to generate
executable code. Background compilation was initially introduced
with Microsoft Visual Basic but has now been expanded for all
included languages.
Debugger
Main article: Microsoft Visual Studio Debugger

Visual Studio includes a debugger that works both as a source-level
debugger and as a machine-level debugger. It works with both
managed code as well as native code and can be used for debugging
applications written in any language supported by Visual Studio. In
addition, it can also attach to running processes and monitor and
debug those processes. If source code for the running process is
available, it displays the code as it is being run. If source code is not
available, it can show the disassembly. The Visual Studio debugger
can also create memory dumps as well as load them later for
debugging. Multi-threaded programs are also supported. The
debugger can be configured to be launched when an application
running outside the Visual Studio environment crashes.


The debugger allows setting breakpoints (which allow execution to
be stopped temporarily at a certain position) and watches (which
monitor the values of variables as the execution progresses).
Breakpoints can be conditional, meaning they get triggered when
the condition is met. Code can be stepped over, i.e., run one line (of
source code) at a time. It can either step into functions to debug
inside it, or step over it, i.e., the execution of the function body isn't

                                                          22
                          TEXT TO SPEECH

available for manual inspection. The debugger supports Edit and
Continue, i.e., it allows code to be edited as it is being debugged (32
bit only; not supported in 64 bit). When debugging, if the mouse
pointer hovers over any variable, its current value is displayed in a
tooltip ("data tooltips"), where it can also be modified if desired.
During coding, the Visual Studio debugger lets certain functions be
invoked manually from the Immediate tool window. The parameters
to the method are supplied at the Immediate window.
Designer


Visual Studio includes a host of visual designers to aid in the
development of applications. These tools include:
Windows Forms Designer

    o The Windows Forms designer is used to build GUI
      applications using Windows Forms. Layout can be controlled
      by housing the controls inside other containers or locking
      them to the side of the form. Controls that display data (like
      textbox, list box, grid view, etc.) can be bound to data
      sources like databases or queries. Data-bound controls can be
      created by dragging items from the Data Sources window
      onto a design surface. The UI is linked with code using an
      event-driven programming model. The designer generates
      either C# or VB.NET code for the application.

WPF Designer


                                                        23
                        TEXT TO SPEECH

    o The WPF designer, codenamed Cider, was introduced with
      Visual Studio 2008. Like the Windows Forms designer it
      supports the drag and drop metaphor. It is used to author user
      interfaces targeting Windows Presentation Foundation. It
      supports all WPF functionality including data binding and
      automatic layout management. It generates XAML code for
      the UI. The generated XAML file is compatible with
      Microsoft Expression Design, the designer-oriented product.
      The XAML code is linked with code using a code-behind
      model.




Web designer/development

    o Visual Studio also includes a web-site editor and designer
      that allows web pages to be authored by dragging and
      dropping widgets. It is used for developing ASP.NET
      applications and supports HTML, CSS and JavaScript. It
      uses a code-behind model to link with ASP.NET code. From
      Visual Studio 2008 onwards, the layout engine used by the
      web designer is shared with Microsoft Expression Web.
      There is also ASP.NET MVC support for MVC technology
      as a separate download and ASP.NET Dynamic Data project
      available from Microsoft

Class designer


                                                     24
                         TEXT TO SPEECH

    o The Class Designer is used to author and edit the classes
      (including its members and their access) using UML
      modeling. The Class Designer can generate C# and VB.NET
      code outlines for the classes and methods. It can also
      generate class diagrams from hand-written classes.

Data designer

    o The data designer can be used to graphically edit database
      schemas, including typed tables, primary and foreign keys
      and constraints. It can also be used to design queries from the
      graphical view.

Mapping designer

    o From Visual Studio 2008 onwards, the mapping designer is
      used by LINQ to SQL to design the mapping between
      database schemas and the classes that encapsulate the data.
      The new solution from ORM approach, ADO.NET Entity
      Framework, replaces and improves the old technology.

Other tools


Open Tabs Browser

    o The open tabs browser is used to list all open tabs and to
      switch between them. It is invoked using CTRL+TAB.


                                                      25
                         TEXT TO SPEECH

Properties Editor

    o The Properties Editor tool is used to edit properties in a GUI
      pane inside Visual Studio. It lists all available properties
      (both read-only and those which can be set) for all objects
      including classes, forms, web pages and other items.

Object Browser

    o The Object Browser is a namespace and class library browser
      for Microsoft .NET. It can be used to browse the namespaces
      (which are arranged hierarchically) in managed assemblies.
      The hierarchy may or may not reflect the organization in the
      file system.

Solution Explorer

    o In Visual Studio parlance, a solution is a set of code files and
      other resources that are used to build an application. The files
      in a solution are arranged hierarchically, which might or
      might not reflect the organization in the file system. The
      Solution Explorer is used to manage and browse the files in a
      solution.

Team Explorer

    o Team Explorer is used to integrate the capabilities of Team
      Foundation Server, the Revision Control System into the IDE
      (and the basis for Microsoft's CodePlex hosting environment

                                                      26
                         TEXT TO SPEECH

      for open source projects). In addition to source control it
      provides the ability to view and manage individual work
      items (including bugs, tasks and other documents) and to
      browse TFS statistics. It is included as part of a TFS install
      and is also available as a download for Visual Studio
      separately Team Explorer is also available as a stand-alone
      environment solely to access TFS services.

Data Explorer

    o Data Explorer is used to manage databases on Microsoft
      SQL Server instances. It allows creation and alteration of
      database tables (either by issuing T-SQL commands or by
      using the Data designer). It can also be used to create queries
      and stored procedures, with the latter in either T-SQL or in
      managed code via SQL CLR. Debugging and IntelliSense
      support is available as well.

Server Explorer

    o The Server Explorer tool is used to manage database
      connections on an accessible computer. It is also used to
      browse running Windows Services, performance counters,
      Windows Event Log and message queues and use them as a
      data source.

Dotfuscator Software Services Community Edition



                                                       27
                         TEXT TO SPEECH

    o Visual Studio includes a free 'light' version of PreEmptive
      Solutions' Dotfuscator product for code obfuscation and
      application-size reduction. Starting with Visual Studio 2010,
      this version of Dotfuscator will include Runtime Intelligence
      capabilities that allow authors to gather end-user usage,
      performance, and stability information from their
      applications running in production.

Text Generation Framework

    o Visual Studio includes a full text generation framework
      called T4 which enables Visual Studio to generate text files
      from templates either in the IDE or via code.

ASP.NET Web Site Administration Tool

    o The ASP.NET Web Site Administration Tool allows for the
      configuration of ASP.NET websites.

Extensibility


Visual Studio allows developers to write extensions for Visual
Studio to extend its capabilities. These extensions "plug into" Visual
Studio and extend its functionality. Extensions come in the form of
macros, add-ins, and packages. Macros represent repeatable tasks
and actions that developers can record programmatically for saving,
replaying, and distributing. Macros, however, cannot implement


                                                       28
                          TEXT TO SPEECH

new commands or create tool windows. They are written using
Visual Basic and are not compiled.
Add-Ins provides access to the Visual Studio object model and can
interact with the IDE tools. Add-Ins can be used to implement new
functionality and can add new tool windows. Add-Ins are plugged in
to the IDE via COM and can be created in any COM-compliant
languages. Packages are created using the Visual Studio SDK and
provide the highest level of extensibility. They can create designers
and other tools, as well as integrate other programming languages.
The Visual Studio SDK provides unmanaged APIs as well as a
managed API to accomplish these tasks. However, the managed API
isn't as comprehensive as the unmanaged one. Extensions are
supported in the Standard (and higher) versions of Visual Studio
2005. Express Editions do not support hosting extensions.
Visual Studio 2008 introduced the Visual Studio Shell that allows
for development of a customized version of the IDE. The Visual
Studio Shell defines a set of VS Packages that provide the
functionality required in any IDE. On top of that, other packages
can be added to customize the installation. The Isolated mode of the
shell creates a new AppId where the packages are installed. These
are to be started with a different executable. It is aimed for
development of custom development environments, either for a
specific language or a specific scenario. The Integrated mode
installs the packages into the AppId of the
Professional/Standard/Team System editions, so that the tools
integrate into these editions. The Visual Studio Shell is available as
a free download.


                                                       29
                         TEXT TO SPEECH

After the release of Visual Studio 2008, Microsoft created the
Visual Studio Gallery. It serves as the central location for posting
information about extensions to Visual Studio. Community
developers as well as commercial developers can upload
information about their extensions to Visual Studio .NET 2002
through Visual Studio 2010. Users of the site can rate and review
the extensions to help assess the quality of extensions being posted.
RSS feeds to notify users on updates to the site and tagging features
are also planned.
Supported products

Included products

Microsoft Visual C++
    o Microsoft Visual C++ is Microsoft's implementation of the C and
      C++ compiler and associated languages-services and specific
      tools for integration with the Visual Studio IDE. It can compile
      either in C mode or C++ mode. For C, it follows the ISO C
      standard with parts of C99 spec along with MS-specific
      additions in the form of libraries. For C++, it follows the ANSI
      C++ spec along with a few C++0x features. It also supports the
      C++/CLI spec to write managed code, as well as mixed-mode
      code (a mix of native and managed code). Microsoft positions
      Visual C++ for development in native code or in code that
      contains both native as well as managed components. Visual

                                                       30
                         TEXT TO SPEECH

       C++ supports COM as well as the MFC library. For MFC
       development, it provides a set of wizards for creating and
       customizing MFC boilerplate code, and creating GUI
       applications using MFC. Visual C++ can also use the Visual
       Studio forms designer to design UI graphically. Visual C++ can
       also be used with the Windows API. It also supports the use of
       intrinsic functions, which are functions recognized by the
       compiler itself and not implemented as a library. Intrinsic
       functions are used to expose the SSE instruction set of modern
       CPUs. Visual C++ also includes the Open MP (version 2.0) spec.
Microsoft Visual C#
    o Microsoft Visual C#, Microsoft's implementation of the C#
      language, targets the .NET Framework, along with the language
      services that lets the Visual Studio IDE support C# projects.
      While the language services are a part of Visual Studio, the
      compiler is available separately as a part of the .NET
      Framework. The Visual C# 2008 and 2010 compilers support
      versions 3.0 and 4.0 of the C# language specifications,
      respectively. Visual C# supports the Visual Studio Class
      designer, Forms designer, and Data designer among others.
Microsoft Visual Basic
    o Microsoft Visual Basic is Microsoft's implementation of the
      VB.NET language and associated tools and language services. It
      was introduced with Visual Studio .NET (2002). Microsoft has
                                                       31
                          TEXT TO SPEECH

      positioned Visual Basic for Rapid Application
      Development.[43][44] Visual Basic can be used to author both
      console applications as well as GUI applications. Like Visual C#,
      Visual Basic also supports the Visual Studio Class designer,
      Forms designer, and Data designer among others. Like C#, the
      VB.NET compiler is also available as a part of .NET Framework,
      but the language services that let VB.NET projects be developed
      with Visual Studio, are available as a part of the latter.
Microsoft Visual Web Developer
    o Microsoft Visual Web Developer is used to create web sites,
      web applications and web services using ASP.NET. Either C# or
      VB.NET languages can be used. Visual Web Developer can use
      the Visual Studio Web Designer to graphically design web page
      layouts.
Team Foundation Server
    o Included only with Visual Studio Team System, Team
      Foundation Server is intended for collaborative software
      development projects and acts as the server-side backend
      providing source control, data collection, reporting, and
      project-tracking functionality. It also includes the Team
      Explorer, the client tool for TFS services, which is integrated
      inside Visual Studio Team System.



                                                         32
                         TEXT TO SPEECH

Previous products
Visual FoxPro
    o Visual FoxPro is a data-centric object-oriented and procedural
      programming language produced by Microsoft. It derives from
      FoxPro (originally known as FoxBASE) which was developed by
      Fox Software beginning in 1984. Visual FoxPro is tightly
      integrated with its own relational database engine, which
      extends FoxPro's xBase capabilities to support SQL queries and
      data manipulation. Visual FoxPro is a full-feature, dynamic
      programming language that does not require the use of an
      additional general-purpose programming environment.
      Microsoft announced in 2007 that Visual FoxPro has been
      discontinued after version 9 Service Pack 2, but will remain
      supported until 2015.
Visual SourceSafe
    o Microsoft Visual SourceSafe is a source control software
      package oriented towards small software-development
      projects. The SourceSafe database is a multi-user, multi-process
      file-system database, using the Windows file system database
      primitives to provide locking and sharing support. All versions
      are multi-user, using SMB (file server) networking. However,
      with Visual SourceSafe 2005, other client–server modes were
      added, Lan Booster and VSS Internet (which used HTTP/HTTPS).
      Visual SourceSafe 6.0 was available as a stand-alone product

                                                      33
                          TEXT TO SPEECH

       and was included with Visual Studio 6.0, and other products
       such as Office Developer Edition. Visual SourceSafe 2005 was
       available as a stand-alone product and included with the 2005
       Team Suite. Team Foundation Server has superseded VSS as
       Microsoft's recommended platform for source control.
Microsoft Visual J++/Microsoft Visual J#
    o Microsoft Visual J++ was Microsoft's implementation of the
      Java language (with Microsoft-specific extensions) and
      associated language services. It was discontinued as a result of
      litigation from Sun Microsystems, and the technology was
      recycled into Visual J#, Microsoft's Java compiler for .NET
      Framework. J# was available with Visual Studio 2005 but has
      been discontinued in Visual Studio 2008.
Visual InterDev
    o Visual InterDev was used to create web applications using
      Microsoft Active Server Pages (ASP) technologies. It supports
      code completion and includes database server management
      tools. It has been replaced with Microsoft Visual Web
      Developer.

Editions
Microsoft Visual Studio is available in the following editions or
SKUs:


                                                       34
                         TEXT TO SPEECH

Visual Studio Express

Visual Studio Express Editions are a set of free lightweight
individual IDEs which are provided as stripped-down versions of
the Visual Studio IDE on a per-platform basis or per-language basis,
i.e., it installs the development tools for the supported platforms
(web, Windows, phone) or supported development languages (VB,
C#) onto individual Visual Studio Shell AppIds. It includes only a
small set of tools as compared to the other systems. It does not
include support for plug-ins. x64 compilers are not included in the
Visual Studio Express edition IDEs, but are available as part of a
Windows Software Development Kit that can be installed
separately.[51] Starting with Visual Studio Express 11, it will be
restricted to creating Windows 8 Metro (design language) style
applications and will no longer be able to compile desktop
applications without purchasing the Professional version. Microsoft
targets the Express IDEs at students and hobbyists. Express editions
do not use the full MSDN Library but use the MSDN Essentials
Library. The languages available as part of the Express IDEs are:
   Visual Basic Express
   Visual C++ Express
   Visual C# Express
   Visual Web Developer Express
   Express for Windows Phone




                                                     35
TEXT TO SPEECH




(1.2.2)




                 36
                          TEXT TO SPEECH




Visual studio c#

C# (pronounced see sharp) is a multi-paradigm programming language
encompassing strong typing, imperative, declarative, functional,
generic, object-oriented (class-based), and component-oriented
programming disciplines. It was developed by Microsoft within its
.NET initiative and later approved as a standard by Ecma (ECMA-334)
and ISO (ISO/IEC 23270:2006). C# is one of the programming
languages designed for the Common Language Infrastructure.
C# is intended to be a simple, modern, general-purpose, object-oriented
programming language. Its development team is led by Anders
Hejlsberg. The most recent version is C# 4.0, which was released on
April 12, 2010.

Design goals
The ECMA standard lists these design goals for C#:
C# language is intended to be a simple, modern, general-purpose,
object-oriented programming language.
The language, and implementations thereof, should provide support for
software engineering principles such as strong type checking, array
bounds checking, detection of attempts to use uninitialized variables,
and automatic garbage collection. Software robustness, durability, and
programmer productivity are important.

                                                        37
                           TEXT TO SPEECH

The language is intended for use in developing software components
suitable for deployment in distributed environments.
Source code portability is very important, as is programmer portability,
especially for those programmers already familiar with C and C++.
Support for internationalization is very important.
C# is intended to be suitable for writing applications for both hosted and
embedded systems, ranging from the very large that use sophisticated
operating systems, down to the very small having dedicated functions.
Although C# applications are intended to be economical with regard to
memory and processing power requirements, the language was not
intended to compete directly on performance and size with C or
assembly language.
The name "C sharp" was inspired by musical notation where a sharp
indicates that the written note should be made a semitone higher in
pitch. This is similar to the language name of C++, where "++"
indicates that a variable should be incremented by 1.
Due to technical limitations of display (standard fonts, browsers, etc.)
and the fact that the sharp symbol (U+266F ♯ MUSIC SHARP SIGN
(HTML: &#9839 ;)) is not present on the standard keyboard, the
number sign (U+0023 # NUMBER SIGN (HTML: &#35 ;)) was chosen
to represent the sharp symbol in the written name of the programming
language. This convention is reflected in the ECMA-334 C# Language
Specification. However, when it is practical to do so (for example, in
advertising or in box art), Microsoft uses the intended musical symbol.



                                                          38
                            TEXT TO SPEECH

  The "sharp" suffix has been used by a number of other .NET languages
  that are variants of existing languages, including J# (a .NET language
  also designed by Microsoft that is derived from Java 1.1), A# (from
  Ada), and the functional programming language F#. The original
  implementation of Eiffel for .NET was called Eiffel#, a name since
  retired since the full Eiffel language is now supported. The suffix has
  also been used for libraries, such as Gtk# (a .NET wrapper for GTK+
  and other GNOME libraries), Cocoa# (a wrapper for Cocoa) and Qt# (a
  .NET language binding for the Qt toolkit).

History

  During the development of the .NET Framework, the class libraries
  were originally written using a managed code compiler system called
  Simple Managed C (SMC).
  In January 1999, Anders Hejlsberg formed a team to build a new
  language at the time called Cool, which stood for "C-like Object
  Oriented Language. Microsoft had considered keeping the name "Cool"
  as the final name of the language, but chose not to do so for trademark
  reasons. By the time the .NET project was publicly announced at the
  July 2000 Professional Developers Conference, the language had been
  renamed C#, and the class libraries and ASP.NET runtime had been
  ported to C#.
  C#'s principal designer and lead architect at Microsoft is Anders
  Hejlsberg, who was previously involved with the design of Turbo
  Pascal, Embarcadero Delphi (formerly Code Gear Delphi and Borland
  Delphi), and Visual J++. In interviews and technical papers he has
  stated that flaws in most major programming languages (e.g. C++, Java,
  Delphi, and Smalltalk) drove the fundamentals of the Common


                                                          39
                           TEXT TO SPEECH

Language Runtime (CLR), which, in turn, drove the design of the C#
language itself.
James Gosling, who created the Java programming language in 1994,
and Bill Joy, a co-founder of Sun Microsystems, the originator of Java,
called C# an "imitation" of Java; Gosling further claimed that "[C# is]
sort of Java with reliability, productivity and security deleted. Klaus
Kreft and Angelika Langer (authors of a C++ streams book) stated in a
blog post that "Java and C# are almost identical programming
languages. Boring repetition that lacks innovation," "Hardly anybody
will claim that Java or C# are revolutionary programming languages
that changed the way we write programs," and "C# borrowed a lot from
Java - and vice versa. Now that C# supports boxing and unboxing, we'll
have a very similar feature in Java." Anders Hejlsberg has argued that
C# is "not a Java clone" and is "much closer to C++" in its design.
Since the release of C# 2.0 in November 2005, the C# and Java
languages have evolved on increasingly divergent trajectories,
becoming somewhat less similar. One of the first major departures came
with the addition of generics to both languages, with vastly different
implementations. C# makes use of reification to provide "first-class"
generic objects that can be used like any other class, with code
generation performed at class-load time. By contrast, Java's generics are
essentially a language syntax feature, and they do not affect the
generated byte code, because the compiler performs type erasure on the
generic type information after it has verified its correctness.
Furthermore, C# has added several major features to accommodate
functional-style programming, culminating in their LINQ extensions
released with C# 3.0 and its supporting framework of lambda
expressions, extension methods, and anonymous types. These features
enable C# programmers to use functional programming techniques,
                                                         40
                          TEXT TO SPEECH

such as closures, when it is advantageous to their application. The
LINQ extensions and the functional imports help developers reduce the
amount of "boilerplate" code that is included in common tasks like
querying a database, parsing an xml file, or searching through a data
structure, shifting the emphasis onto the actual program logic to help
improve readability and maintainability.
C# used to have a mascot called Andy (named after Anders Hejlsberg).
It was retired on 29 Jan 2004.
C# was originally submitted for review to the ISO subcommittee JTC
1/SC 22
Under ISO/IEC 23270:2003, which is now withdrawn? It was then
approved under ISO/IEC 23270:2006.

Syntax
Main article: C Sharp syntax
See also: Syntax (programming languages)
C# has the following syntax:
Semicolons are used to denote the end of a statement.
Curly braces are used to group statements. Statements are commonly
grouped into functions, functions into classes, and classes into
namespaces.
Variables are declared using an equal's sign, but compared using two
consecutive equals' signs.



                                                        41
                           TEXT TO SPEECH

Square brackets are used with arrays, both to declare them and to get a
value at a given index in one of them.
Distinguishing features
     o Note: The following description is based on the language
       standard and other documents listed in the "External links"
       section.

By design, C# is the programming language that most directly reflects
the underlying Common Language Infrastructure (CLI) Most of its
intrinsic types correspond to value-types implemented by the CLI
framework. However, the language specification does not state the code
generation requirements of the compiler: that is, it does not state that a
C# compiler must target a Common Language Runtime, or generate
Common Intermediate Language (CIL), or generate any other specific
format. Theoretically, a C# compiler could generate machine code like
traditional compilers of C++ or FORTRAN.
Some notable features of C# that distinguish it from C and C++ (and
Java, where noted) are:
It has no global variables or functions. All methods and members must
be declared within classes. Static members of public classes can
substitute for global variables and functions.

Local variables cannot shadow variables of the enclosing block, unlike C
and C++. Variable shadowing is often considered confusing by C++
texts.

C# supports a strict Boolean data type, bool. Statements that take
conditions, such as while and if, require an expression of a type that
implements the true operator, such as the Boolean type. While C++ also
has a Boolean type, it can be freely converted to and from integers, and


                                                          42
                            TEXT TO SPEECH

expressions such as if (a) require only that a is convertible to bool,
allowing a to be an int, or a pointer. C# disallows this "integer meaning
true or false" approach, on the grounds that forcing programmers to use
expressions that return exactly bool can prevent certain types of common
programming mistakes in C or C++ such as if (a = b) (use of
assignment = instead of equality ==).

In C#, memory address pointers can only be used within blocks
specifically marked as unsafe, and programs with unsafe code need
appropriate permissions to run. Most object access is done through safe
object references, which always either point to a "live" object or have the
well-defined null value; it is impossible to obtain a reference to a "dead"
object (one that has been garbage collected), or to a random block of
memory. An unsafe pointer can point to an instance of a value-type,
array, string, or a block of memory allocated on a stack. Code that is not
marked as unsafe can still store and manipulate pointers through the
System.IntPtr type, but it cannot dereference them.

Managed memory cannot be explicitly freed; instead, it is automatically
garbage collected. Garbage collection addresses the problem of memory
leaks by freeing the programmer of responsibility for releasing memory
that is no longer needed.

In addition to the try...catch construct to handle exceptions, C# has a
try...finally construct to guarantee execution of the code in the finally
block.

Multiple inheritances are not supported, although a class can implement
any number of interfaces. This was a design decision by the language's
lead architect to avoid complication and simplify architectural
requirements throughout CLI.

C#, like C++, but unlike Java, supports operator overloading.


                                                            43
                            TEXT TO SPEECH

 C# is more type safe than C++. The only implicit conversions by default
 are those that are considered safe, such as widening of integers. This is
 enforced at compile-time, during JIT, and, in some cases, at runtime. No
 implicit conversions occur between booleans and integers, or between
 enumeration members and integers (except for literal 0, which can be
 implicitly converted to any enumerated type). Any user-defined
 conversion must be explicitly marked as explicit or implicit, unlike C++
 copy constructors and conversion operators, which are both implicit by
 default. Starting with version 4.0, C# supports a "dynamic" data type
 that enforces type checking at runtime only.

 Enumeration members are placed in their own scope.

 C# provides properties as syntactic sugar for a common pattern in which
 a pair of methods, accessor (getter) and mutator (setter) encapsulate
 operations on a single attribute of a class. No redundant method
 signatures for the getter/setter implementations need be written, and the
 property may be accessed using attribute syntax rather than more
 verbose method calls.

 Checked exceptions are not present in C# (in contrast to Java). This has
 been a conscious decision based on the issues of scalability and version
 ability.

 Though primarily an imperative language, since C# 3.0 it supports
 functional programming techniques through first-class function objects
 and lambda expressions.

Common type system

 C# has a unified type system. This unified type system is called
 Common Type System (CTS).



                                                           44
                            TEXT TO SPEECH

A unified type system implies that all types, including primitives such
as integers, are subclasses of the System .Object class. For example,
every type inherits a To String() method.
Categories of data types

CTS separate data types into two categories:
Value types
Reference types

Instances of value types do not have referential identity or referential
comparison semantics - equality and inequality comparisons for value
types compare the actual data values within the instances, unless the
corresponding operators are overloaded. Value types are derived from
System .Value Type, always have a default value, and can always be
created and copied. Some other limitations on value types are that they
cannot derive from each other (but can implement interfaces) and
cannot have an explicit default (parameter less) constructor. Examples
of value types are all primitive types, such as int (a signed 32-bit
integer), float (a 32-bit IEEE floating-point number), char (a 16-bit
Unicode code unit), and System .Date Time (identifies a specific point
in time with nanosecond precision). Other examples are enum
(enumerations) and struct (user defined structures).
In contrast, reference types have the notion of referential identity - each
instance of a reference type is inherently distinct from every other
instance, even if the data within both instances is the same. This is
reflected in default equality and inequality comparisons for reference
types, which test for referential rather than structural equality, unless the
corresponding operators are overloaded (such as the case for System


                                                            45
                           TEXT TO SPEECH

.String). In general, it is not always possible to create an instance of a
reference type, nor to copy an existing instance, or perform a value
comparison on two existing instances, though specific reference types
can provide such services by exposing a public constructor or
implementing a corresponding interface (such as ICloneable or
IComparable). Examples of reference types are object (the ultimate base
class for all other C# classes), System .String (a string of Unicode
characters), and System .Array (a base class for all C# arrays).
Both type categories are extensible with user-defined types.


Boxing and unboxing

Boxing is the operation of converting a value of a type of value into a
value of a corresponding reference type.[29] Boxing in C# is implicit.
Unboxing is the operation of converting a value of a reference type
(previously boxed) into a value of a value type.[29] Unboxing in C#
requires an explicit type cast. A boxed object of type T can only be
unboxed to a T (or a nullable T).
Generics

Generics were added to version 2.0 of the C# language. Generics use
type parameters, which make it possible to design classes and methods
that do not specify the type used until the class or method is
instantiated. The main advantage is that one can use generic type
parameters to create classes and methods that can be used without
incurring the cost of runtime casts or boxing operations, as shown here:



                                                          46
                             TEXT TO SPEECH

Preprocessor

 C# features "preprocessor directives (though it does not have an actual
 preprocessor) based on the C preprocessor that allow programmers to
 define symbols, but not macros. Conditionals such as #if, #endif, and
 #else are also provided.

Code comments

 C# utilizes a double forward slash (//) to indicate the rest of the line is a
 comment. This is inherited from C++.
 Multi-line comments can be indicated by a starting forward
 slash/asterisk (/*) and ending asterisk/forward slash (*/). This is
 inherited from standard C.

XML documentation system

 C#'s documentation system is similar to Java's Javadoc, but based on
 XML. Two methods of documentation are currently supported by the
 C# compiler.
 Single-line documentation comments, such as those commonly found in
 Visual Studio generated code, are indicated on a line beginning with ///.


 Multi-line documentation comments, while defined in the version 1.0
 language specification, were not supported until the .NET 1.1 releases.
 These comments are designated by a starting forward
 slash/asterisk/asterisk (/**) and ending asterisk/forward slash (*/).



                                                              47
                             TEXT TO SPEECH

Libraries

  The C# specification details a minimum set of types and class libraries
  that the compiler expects to have available. In practice, C# is most often
  used with some implementation of the Common Language
  Infrastructure (CLI), which is standardized as ECMA-335 Common
  Language Infrastructure (CLI).

Standardization and licensing
  In August, 2000, Microsoft Corporation, Hewlett-Packard and Intel
  Corporation co-sponsored the submission of specifications for C# as
  well as the Common Language Infrastructure (CLI) to the standards
  organization Ecma International. In December 2001, ECMA released
  ECMA-334 C# Language Specification. C# became an ISO standard in
  2003 (ISO/IEC 23270:2003 - Information technology — Programming
  languages — C#). ECMA had previously adopted equivalent
  specifications as the 2nd edition of C#, in December 2002.
  In June 2005, ECMA approved edition 3 of the C# specification, and
  updated ECMA-334. Additions included partial classes, anonymous
  methods, nullable types, and generics (similar to C++ templates).
  In July 2005, ECMA submitted the standards and related TRs to
  ISO/IEC JTC 1 via the latter's Fast-Track process. This process usually
  takes 6–9 months.
  The C# language definition and the CLI are standardized under ISO and
  Ecma standards that provide reasonable and non-discriminatory
  licensing protection from patent claims. However, Microsoft uses C#
  and the CLI in its Base Class Library (BCL) that is the foundation of its
  proprietary .NET framework, and which provides a variety of non-

                                                            48
                           TEXT TO SPEECH

standardized classes (extended I/O, GUI, Web services, etc.). Some
cases where Microsoft patents apply to standards used in the .NET
framework are documented by Microsoft and the applicable patents are
available on either RAND terms or through Microsoft's Open
Specification Promise that releases patent rights to the public, but there
is some concern and debate as to whether there are additional aspects
patented by Microsoft that are not covered, which may deter
independent implementations of the full framework.
Microsoft has agreed not to sue open source developers for violating
patents in non-profit projects for the part of the framework that is
covered by the OSP. Microsoft has also agreed not to enforce patents
relating to Novell products against Novell's paying customers with the
exception of a list of products that do not explicitly mention C#, .NET
or Novell's implementation of .NET (The Mono Project). However,
Novell maintains that Mono does not infringe any Microsoft patents.
Microsoft has also made a specific agreement not to enforce patent
rights related to the Moonlight browser plugin, which depends on
Mono, provided it is obtained through Novell.
In a note posted on the Free Software Foundation's news website in
June 2009, Richard Stallman warned that he believes that "Microsoft is
probably planning to force all free C# implementations underground
some day using software patents", and recommended that developers
avoid taking what he described as the "gratuitous risk" associated with
"depend[ing] on the free C# implementations". The Free Software
Foundation later reiterated its warnings, claiming that the extension of
Microsoft Community Promise to the C# and the CLI ECMA
specifications would not prevent Microsoft from harming free
implementations of C#, because many specific Windows libraries
included with .NET or Mono were not covered by this promise.

                                                           49
                          TEXT TO SPEECH

Implementations
The reference C# compiler is Microsoft Visual C#.
Other C# compilers exist, often including an implementation of the
Common Language Infrastructure and the .NET class libraries up to
.NET 2.0:
The Mono project provides an open source C# compiler, a complete
open source implementation of the Common Language Infrastructure
including the required framework libraries as they appear in the ECMA
specification, and a nearly complete implementation of the Microsoft
proprietary .NET class libraries up to .NET 3.5. As of Mono 2.6, no
plans exist to implement WPF; WF is planned for a later release; and
there are only partial implementations of LINQ to SQL and WCF.
The DotGNU project also provides an open source C# compiler, a
nearly complete implementation of the Common Language
Infrastructure including the required framework libraries as they appear
in the ECMA specification, and subset of some of the remaining
Microsoft proprietary .NET class libraries up to .NET 2.0 (those not
documented or included in the ECMA specification, but included in
Microsoft's standard .NET Framework distribution).
Microsoft's Rotor project (currently called Shared Source Common
Language Infrastructure) (licensed for educational and research use
only) provides a shared source implementation of the CLR runtime and
a C# compiler, and a subset of the required Common Language
Infrastructure framework libraries in the ECMA specification (up to C#
2.0, and supported on Windows XP only).



                                                         50
                           TEXT TO SPEECH

The DotNet Anywhere Micro Framework-like Common Language
Runtime is targeted at embedded systems, and supports almost all C#
2.0 specifications. It is licensed under the MIT License conditions and
is implemented in C.




                                                         51
     TEXT TO SPEECH




      (1.3)
Project objectives




                      52
                           TEXT TO SPEECH




  Project objectives

The huge quantity of dynamic data that people need to check, on
the move, about their daily activities as news, sports, weather,
stock options, bank accounts, E-mails etc., is on the rise. It thus
needs a powerful TTS engine that converts them into human
voice in real time, and at the same time to be able to handle the
tremendous load of telephone calls using the latest techniques in
load balancing and streaming.




                                                       53
       TEXT TO SPEECH




   Chapter (2.1)
Survey about project




                        54
                         TEXT TO SPEECH




  Survey about project

How a TTS can help businesses?
The huge quantity of dynamic data that people need to
check, on the move, about their daily activities as news,
sports, weather, stock options, bank accounts, E-mails etc., is
on the rise. It thus needs a powerful TTS engine that
converts them into human voice in real time, and at the
same time to be able to handle the tremendous load of
telephone calls using the latest techniques in load balancing
and streaming.
How a TTS technology can save money and time?
The TTS technology is becoming inevitable in some
businesses that need to feed their customers with the latest
and vital information in real time. These businesses usually
use IVR (Interactive Voice Response) systems and call
centers to communicate this information to their customers
and prospects. Converting vital data stored in Web sites,

                                                   55
                          TEXT TO SPEECH

databases and files into human voice using the traditional
expensive and time-consuming human recordings in studios
is becoming a hard and long process since the information is
usually dynamic. In some cases, it would be impossible to
track these changes using the human recordings way. Only a
powerful TTS engine that supports Arabic and English
languages can be the right solution for the information
stored in IVR systems and call centers
Why an Arabic TTS is different?
Arabic is a difficult language and it is not like languages as
English, French, or Spanish. Those languages, written in Latin
alphabet, have vowels while the Arabic language has special
characters called "diacritics". These diacritics give the Arabic
words the correct meaning inside a sentence. For example,
two Arabic words that have different meanings can be
written exactly the same and only the diacritics can help the
reader to distinguish them.
For this reason, TTS developed the Discretizer engine. This
engine can put the diacritics needed in Arabic texts
automatically. The Diacritizer is the main component in


                                                    56
                         TEXT TO SPEECH

Arabic TTS. Without the Diacritizer, the output quality of the
TTS engine would be inaccurate and not clear. Since Arabic
native speakers write Arabic text without diacritics, the TTS
engine should handle the non-diacritized text. The Diacritizer
will convert the non-diacritized text into a diacritized text
and then the TTS engine will convert it to a clear and human
.Arabic voice
The Linguistic Module
This module is composed of four parts: Text Normalization,
Grapheme to Phoneme (G2P) conversion, Lexical Analysis
and Syntactic Analysis. Text Normalization handles language
dependent abbreviations, dates, currencies, time indications,
phone numbers and other special symbols. It also correctly
handles quotation marks, Parentheses, apostrophes and
punctuation marks. After Grapheme to Phoneme conversion,
the system resolves pronunciation ambiguities, through
lexical and syntactic analysis, and identifies the proper
prosodic phrases for each sentence. The output is a phonetic
representation of the input text
The Phonetic Module


                                                   57
                        TEXT TO SPEECH

The Phonetic Module performs segmental synthesis and
creates high quality prosodic patterns. In order to create
synthetic speech, TTS engine is flexible enough to use the
proper speech segments such as diphones, triphones,
tetraphones or much more. Those segments, which are
taken from human speech, preserve phoneme transitions as
well as co-articulation effects. By concatenating the speech
segments, high quality synthetic speech is obtained. To
synthesize intelligible and natural sounding speech, it is
essential to create good prosodic characteristics. This is
accomplished through the production of good intonation
contours and the assignment of the correct duration to each
phoneme
The Acoustic Module
The Acoustic Processing Module converts the speech data
that was created previously, into speech signals.
The TTS concatenation of speech segments and the synthesis
of prosody are based on the latest synthesis techniques.
The output is an array of wave samples with sampling rates
Development Tools & Application Programming Interface

                                                 58
                        TEXT TO SPEECH

For TTS customers, Application Programming Interfaces (API)
are available in a Software Development Kit (SDK), ActiveX
control and COM object. The functionality of the APIs varies
depending on the market and the intended use of the end
product. Some of the functions of the APIs are to provide the
application developer a way to initiate and stop the text-to-
speech synthesis, select the correct exception dictionaries,
as well as load the proper application and language.
Feature Set
Convert any computer text into natural sounding
speech output with phonetic input support
Natural sounding speech output in male voice
TTS SDK is a Windows based SW package for
application developers and prototyping
Supports Arabic Language as default and
automatically




                                                  59
     TEXT TO SPEECH




  Chapter (3.1)
Project analysis




                      60
  TEXT TO SPEECH




  (3.1.1)
Use cases


                   61
            TEXT TO SPEECH




Use Case Diagram:




                             62
TEXT TO SPEECH




                 63
TEXT TO SPEECH




                 64
TEXT TO SPEECH




                 65
TEXT TO SPEECH




                 66
TEXT TO SPEECH




                 67
TEXT TO SPEECH




                 68
     TEXT TO SPEECH




     (3.1.2)

Sequence diagram




                      69
          TEXT TO SPEECH




Sequence diagram:




                           70
TEXT TO SPEECH




                 71
TEXT TO SPEECH




                 72
TEXT TO SPEECH




                 73
TEXT TO SPEECH




                 74
TEXT TO SPEECH




                 75
TEXT TO SPEECH




                 76
TEXT TO SPEECH




                 77
     TEXT TO SPEECH




  Chapter (4.1)


Implementation



                      78
           TEXT TO SPEECH




User interface:




                            79
                   TEXT TO SPEECH




Program coding:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
namespace Concatenation_Waves
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        public int testlam(char[] a)
        {
        // char[] a = new char[5];
        if (a[0] == '‫ && 'ا‬a[2] == '‫)'ل‬

                                          80
           TEXT TO SPEECH

    {
        if (a[4] == '‫'ت‬
           || a[4] == '‫'ث‬
           || a[4] == '‫'د‬
           || a[4] == '‫'ذ‬
           || a[4] == '‫'س‬
           || a[4] == '‫'ش‬
           || a[4] == '‫'ص‬
           || a[4] == '‫'ض‬
           || a[4] == '‫'ط‬
           || a[4] == '‫'ظ‬
           || a[4] == '‫'ل‬
           || a[4] == '‫'ن‬
           || a[4] == '‫'ر‬
           || a[4] == '‫)'ز‬

               return 0;
        else
               return 1;
    }
    else
        return 0;
  }
public static string numbertotext (int n)
{
    if (n == 0)
                   ِْ
        return " ْ‫;"صفر‬
    else if (n <= 19)
                               81
                                         TEXT TO SPEECH

                                   return new string[] {"‫, "و ْاحد‬                     ِْ َ
                     ْ َ
"‫,"خمسْ " ,"اَرْ بَع" ,"ثََلَث" ,"اِثِنَاِن‬
   ْ                             ْ                ْ َ
                                       "‫,"ثَماْن" ,"سبع" ,"ست‬
                                            ْ ِ             ْ َْ          ْ َ
                                          ْ ْ             ْ ْ َ
                                       "‫,"اَحدعشرْ " ,"عشرْ ه","تِسع‬        ْ َ ََ
                                              ْ َ ْ                   َْْ
                                       " ْ‫عشرْ اَرْ بَعْت " ,"عشرْ ثََلثت " ,"اِثنَاْعشر‬
                                                                               ْ َ              َ     ْ َ
           َ َ ْ َ
", "‫,"عشرْ خمست‬        ْ َ
                                       "‫ثَماْنِيَت" ,"عشرْ سبعت" ,"عشرْ ستَت‬
                                           َ ِ          ْ َ          َ ََْ         ْ َ            َ َ
  ْ َ          ْ َ ْ       ْ َ
ْ‫[}"عشرْ تِسعت","عشر‬n - 1] + "‫;"و‬
                             else if (n <= 99)
                                   return new string[] { "‫,"عشرن‬                         ْ ْ ِ
"‫} "تسْعن" ,"ثَمنن" ,"سبْعن" ,"سْتن" ,"خمسن" ,"اَرْ بْعن" ,"ثَلَثن‬
     ْ             ْ            ْ ْ َ           ْ                ْ َ            ْ َ            ْ ْ
                                       [n / 10 - 2] + "‫+ "و‬
numbertotext(n % 10);
                             else if (n <= 199)
                                   return "‫ + "ماَه‬numbertotext(n %
                                                    ْ َ
100);

                         return n.ToString();
                }

        public void button1_Click(object sender,
EventArgs e)
        {


                         string mytext = richTextBox1.Text;
                         char[] aa2 = mytext.ToCharArray();
                         string mytext2;
                                                                                   82
                       TEXT TO SPEECH

            int again=0;
            int number;
            //for(again=1; again <= mytext.Length;
again++)
            //{
            //         mytext2 = aa2.ToString();
            //        for(mytext=number ; aa2<=)


            //}
            int m=0;
            string s1=" ";
            int i = 0;

            foreach (char c in aa2)
            {


                  if (char.IsNumber(c))
                  {
                      s1.Insert(s1.Length,
c.ToString());
                        m = Convert.ToInt32(s1);
                  }


                  s1 = numbertotext(m);
                  label1.Text = s1;
                                           83
                   TEXT TO SPEECH

            }


            string[] files = new
string[mytext.Length];


            int length = mytext.Length;


            Boolean visitedIndex = false;
            //MessageBox.Show("files = " +
(mytext.Length).ToString());
            int index;
            int indexFile =-1;
            // while (index != length)
            string WavePath =
"C:\\Users\\Hisham\\Desktop\\MICKEY\\4\\c\\";
            string outwavefile = WavePath +
"out.wav";
            char[] a = new char[5];
            string[] num = new
string[mytext.Length];

            if (num[0] == "1")
            {



                                          84
                   TEXT TO SPEECH

                num[indexFile] = WavePath +
"waw1.wav" + "alef1.wav" + "hahs.wav" +
"dals.wav";

            }


            for ( index = 0; index <
mytext.Length; index++)
            {
                int speak = 0;
                //if (mytext.Length-index<4)
char[] a =
{mytext[index],mytext[index+1],mytext[index+2],myt
ext[index+3],mytext[index+4]};

                if (mytext.Length - index > 5)
                {
                    a[0] = mytext[index];
                    a[1] = mytext[index + 1];
                    a[2] = mytext[index + 2];
                    a[3] = mytext[index + 3];
                    a[4] = mytext[index + 4];
                    speak = testlam(a);
                }
                  // speak = testlam(a);
                MessageBox.Show("index " + index);
                MessageBox.Show("speak " + speak);
                                       85
                    TEXT TO SPEECH


                switch (mytext[index])
                {
                    case '‫:'ا‬
                        //
                        MessageBox.Show("‫;)"ا‬
                        visitedIndex = true;
                        //    files[index] =
"C:\\Project\\el7roof\\kasra\\alef2.wav";
                        index++;visitedIndex =
false;

//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                //

//MessageBox.Show("‫ أ‬fatha ----------");
                                 visitedIndex =
true;
                                 indexFile++;

                                     files[indexFile] =
WavePath + "alef1.wav";
                                     // index++;
                                            86
                    TEXT TO SPEECH


//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                                break;
                            case "1615":// dama
                                //

//MessageBox.Show("‫ أ‬dama");
                                     visitedIndex =
true;
                                     indexFile++;
                                     files[indexFile] =
WavePath + "alef3.wav";
                                // index++;
                               //
MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                            case "1616"://kasra
                                //
                               //
MessageBox.Show("‫ أ‬kasra");
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "alef2.wav";
                                 //index++;
                                            87
                   TEXT TO SPEECH

                               //
MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                            case "1618"://skon
                                //
                               //
MessageBox.Show("‫ أ‬skon");
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "alefs.wav";
                                //index++;
                              //
MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                            default:
                               // char ss =
mytext[index];
                                MessageBox.Show("Ã
default");
                                visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());


                                       88
                   TEXT TO SPEECH


MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;
             //       case 'È':
             //           //
             //           MessageBox.Show("È");
             //           visitedIndex = true;
             //           files[index] =
"C:\\Users\\marey\\Desktop\\wave
c++\\MAAR\\el7roof\\beh2.wav";
             //           //index++;
             //           break;
                    case '‫:'ب‬
                        //
                        MessageBox.Show("‫;)"ب‬
                        visitedIndex = true;
                        //   files[index] =
"C:\\Users\\marey\\Desktop\\wave
c++\\MAAR\\el7roof\\beh2.wav";
                        index++; visitedIndex =
false;

//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                                       89
                   TEXT TO SPEECH

                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                //

//MessageBox.Show("È fatha ----------");
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "beh1.wav";
                                // index++;

//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                                break;
                            case "1615":// dama
                                //

//MessageBox.Show("È dama");
                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "beh3.wav";
                                    //   index++;


                                            90
                   TEXT TO SPEECH


//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                                break;
                            case "1616"://kasra
                                //

//MessageBox.Show("È kasra");
                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "beh2.wav";
                                    //index++;

//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                                break;
                            case "1618"://skon
                                //

//MessageBox.Show("È skon");
                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "behs.wav";
                                    //index++;
                                           91
                   TEXT TO SPEECH


//MessageBox.Show("indexFile " + indexFile +
"index " + index);
                                break;
                            default:
                                //
                                // char ss =
mytext[index];
                                MessageBox.Show("Ã
default");
                                visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

//////////////////////////////////////////////////
///////////

                    case '‫:'ت‬

                        MessageBox.Show("‫;)"ت‬
                                       92
                   TEXT TO SPEECH

                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "teh1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "teh3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "teh2.wav";
                                break;
                            case "1618"://skon
                                       93
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "tehs.wav";
                                 break;
                             default:
                                 MessageBox.Show("Ã
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'ث‬

                         MessageBox.Show("‫;)"ث‬
                         visitedIndex = true;
                         index++; visitedIndex =
false;


                                           94
                   TEXT TO SPEECH

                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "theh1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "theh3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "theh2.wav";
                                break;
                            case "1618"://skon
                                visitedIndex =
true;
                                indexFile++;
                                       95
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "thehs.wav";
                                 break;
                             default:
                                 MessageBox.Show("Ã
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                          break;

                    case '‫:'ج‬

                          MessageBox.Show("‫;)"ج‬
                          visitedIndex = true;
                          index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                           96
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "gem1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "gem3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "gem2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "gems.wav";
                                 break;
                             default:
                                           97
                   TEXT TO SPEECH

                                    MessageBox.Show("Ã
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;


                    case '‫:'ح‬

                        MessageBox.Show("‫;)"ح‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                           98
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "hah1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "hah3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "hah2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "hahs.wav";
                                 break;
                             default:
                                 MessageBox.Show("Ã
default");


                                           99
                   TEXT TO SPEECH

                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'خ‬

                        MessageBox.Show("‫;)"خ‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "khah1.wav";
                                break;
                                           100
                   TEXT TO SPEECH

                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "khah3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "khah2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "khahs.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫خ‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());
                                           101
                   TEXT TO SPEECH


MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'د‬

                        MessageBox.Show("‫;)"د‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "dal1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                       102
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "dal3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "dal2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "dals.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫د‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                                           103
                   TEXT TO SPEECH

                        }

                        break;

                    case '‫:'ذ‬

                        MessageBox.Show("‫;)"ذ‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zal1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zal3.wav";
                                break;
                            case "1616"://kasra
                                       104
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "zal2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "zals.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ذ‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;


                                           105
                   TEXT TO SPEECH

                    case '‫:'ر‬

                        MessageBox.Show("‫;)"ر‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "reh1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "reh3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;


                                       106
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "reh2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "rehs.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ر‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'ز‬

                         MessageBox.Show("‫;)"ز‬
                                           107
                   TEXT TO SPEECH

                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zal1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zal3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zal2.wav";
                                break;
                            case "1618"://skon
                                       108
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "zals.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ز‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'س‬

                         MessageBox.Show("‫;)"س‬
                         visitedIndex = true;
                         index++; visitedIndex =
false;


                                           109
                   TEXT TO SPEECH

                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "sen1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "sen3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "sen2.wav";
                                break;
                            case "1618"://skon
                                visitedIndex =
true;
                                indexFile++;
                                       110
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "sens.wav";
                                 break;
                             default:

MessageBox.Show("‫ س‬default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'ش‬

                         MessageBox.Show("‫;)"ش‬
                         visitedIndex = true;
                         index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                           111
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "shen1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "shen3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "shen2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "shens.wav";
                                 break;
                             default:
                                           112
                   TEXT TO SPEECH


MessageBox.Show("‫ ش‬default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'ص‬

                        MessageBox.Show("‫;)"ص‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;


                                           113
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "sad1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "sad3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "sad2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "sads.wav";
                                 break;
                             default:

MessageBox.Show("‫ ص‬default");


                                           114
                   TEXT TO SPEECH

                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'ض‬

                        MessageBox.Show("‫;)"ض‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "dad1.wav";
                                break;
                                           115
                   TEXT TO SPEECH

                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "dad3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "dad2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "dads.wav";
                                 break;
                             default:

MessageBox.Show("‫ ض‬default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());
                                           116
                   TEXT TO SPEECH


MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'ط‬

                        MessageBox.Show("‫;)"ط‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "tah1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                       117
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "tah3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "tah2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "tahs.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ط‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                                           118
                   TEXT TO SPEECH

                        }

                        break;

                    case '‫:'ظ‬

                        MessageBox.Show("‫;)"ظ‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zah1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "zah3.wav";
                                break;
                            case "1616"://kasra
                                       119
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "zah2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "zahs.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ظ‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;


                                           120
                   TEXT TO SPEECH

                    case '‫:'ع‬

                        MessageBox.Show("‫;)"ع‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "een1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "een3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;


                                       121
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "een2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "eens.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ع‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'غ‬

                         MessageBox.Show("‫;)"غ‬
                                           122
                   TEXT TO SPEECH

                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "ghen1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "ghen3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "ghen2.wav";
                                break;
                            case "1618"://skon
                                       123
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "ghens.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫غ‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                          break;

                    case '‫:'ف‬

                          MessageBox.Show("‫;)"ف‬
                          visitedIndex = true;
                          index++; visitedIndex =
false;


                                           124
                   TEXT TO SPEECH

                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "feh1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "feh3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "feh2.wav";
                                break;
                            case "1618"://skon
                                visitedIndex =
true;
                                indexFile++;
                                       125
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "fehs.wav";
                                 break;
                             default:

MessageBox.Show("‫ ف‬default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'ق‬

                         MessageBox.Show("‫;)"ق‬
                         visitedIndex = true;
                         index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                           126
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "qaf1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "qaf3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "qaf2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "qafs.wav";
                                 break;
                             default:
                                           127
                   TEXT TO SPEECH

                                    MessageBox.Show("‫ق‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'ك‬

                        MessageBox.Show("‫;)"ك‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;


                                           128
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "kaf1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "kaf3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "kaf2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "kafs.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ك‬
default");


                                           129
                   TEXT TO SPEECH

                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'ل‬

                        MessageBox.Show("‫;)"ل‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "lam1.wav";
                                break;
                                           130
                   TEXT TO SPEECH

                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "lam3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "lam2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "lams.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ل‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());
                                           131
                   TEXT TO SPEECH


MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case '‫:'م‬

                        MessageBox.Show("‫;)"م‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "mem1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                       132
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "mem3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "mem2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "mems.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫م‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                                           133
                   TEXT TO SPEECH

                        }

                        break;

                    case '‫:'ن‬

                        MessageBox.Show("‫;)"ن‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "non1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "non3.wav";
                                break;
                            case "1616"://kasra
                                       134
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "non2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "nons.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ن‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;


                                           135
                   TEXT TO SPEECH

                    case '‫:'ه‬

                        MessageBox.Show("‫;)"ه‬
                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "heh1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "heh3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;


                                       136
                   TEXT TO SPEECH

                                    files[indexFile] =
WavePath + "heh2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "hehs.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫ه‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                         break;

                    case '‫:'و‬

                         MessageBox.Show("‫;)"و‬
                                           137
                   TEXT TO SPEECH

                        visitedIndex = true;
                        index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                        {
                            case "1614": //fatha
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "waw1.wav";
                                break;
                            case "1615":// dama
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "waw3.wav";
                                break;
                            case "1616"://kasra
                                visitedIndex =
true;
                                indexFile++;
                                files[indexFile] =
WavePath + "waw2.wav";
                                break;
                            case "1618"://skon
                                       138
                   TEXT TO SPEECH

                                    visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "waws.wav";
                                 break;
                             default:
                                 MessageBox.Show("‫و‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }
                        break;

                    case '‫:'ى‬

                         MessageBox.Show("‫;)"ى‬
                         visitedIndex = true;
                         index++; visitedIndex =
false;
                        switch
(((int)mytext[index]).ToString())
                                           139
                   TEXT TO SPEECH

                         {
                             case "1614": //fatha
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "yeh1.wav";
                                 break;
                             case "1615":// dama
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "yeh3.wav";
                                 break;
                             case "1616"://kasra
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "yeh2.wav";
                                 break;
                             case "1618"://skon
                                 visitedIndex =
true;
                                    indexFile++;
                                    files[indexFile] =
WavePath + "yehs.wav";
                                           140
                   TEXT TO SPEECH

                                 break;
                             default:
                                 MessageBox.Show("‫ى‬
default");
                                    visitedIndex =
false;

MessageBox.Show(((int)mytext[index]).ToString());

MessageBox.Show("indexFile " + indexFile + "index
" + index);
                                break;
                        }

                        break;

                    case ' ':
                        //
                        MessageBox.Show("space ");
                        visitedIndex = true;
                        files[index] =
"C:\\Users\\marey\\Desktop\\wave
c++\\MAAR\\el7roof\\startingspace.wav";
                        //index++;
                        break;
                    default:
                        //


                                           141
                   TEXT TO SPEECH

                        MessageBox.Show(" default
outer switch ");

MessageBox.Show("default");
                        // char ss =
mytext[index];
                        visitedIndex = false;

MessageBox.Show(((int)mytext[index]).ToString());
                        //index++;
                        break;
                }
            }

            MessageBox.Show("end switch");
            MessageBox.Show("indexFile " +
indexFile + "index " + index);
            string[] files2 = new
string[indexFile+1];
            WaveIO wa = new WaveIO();
            Array.Copy(files,files2, indexFile+1);
            wa.Merge(files2, @outwavefile);

            //FileStream fs1 = new
FileStream(@"C:\Users\marey\Desktop\wave
c++\GP\el7roof\dama\alef3.wav", FileMode.Open,
FileAccess.Read);


                                       142
                    TEXT TO SPEECH

            //System.Media.SoundPlayer sp1 = new
System.Media.SoundPlayer(fs1);
            //sp1.Play();


            //FileStream fs2 = new
FileStream(@"C:\Users\marey\Desktop\wave
c++\GP\el7roof\dama\beh3.wav", FileMode.Open,
FileAccess.Read);
            //System.Media.SoundPlayer sp2 = new
System.Media.SoundPlayer(fs2);
            //sp2.Play();

             FileStream fs = new
FileStream(@outwavefile, FileMode.Open,
FileAccess.Read);
             System.Media.SoundPlayer sp3 = new
System.Media.SoundPlayer(fs);
             sp3.Play();
             //fs.Write();
             fs.Close();
             files = null;
             //Close();
        }
        private void Form1_Load(object sender,
EventArgs e)
        {


                                        143
            TEXT TO SPEECH

        }

    }
}




                             144
    TEXT TO SPEECH




 Chapter (5.1)


Conclusion


                     145
                         TEXT TO SPEECH




Conclusion:
 From the above it can be concluded that our program (Text to
  Speech) is useful to a great extent many users convert text to
  audio.
 The program (Text to Speech) utters Arabic-language texts. This
  was not before. Which allows the pronunciation of the characters
  one after one.

 Identified with the correct pronunciation of each character and the
  formation of the letters in Arabic.

 The program (Text to Speech) may provide some services. But
  there is a chance for development and partnership with other
  programs there may be something more useful for users to
  convert text to audio




                                                     146
    TEXT TO SPEECH




(References)



                     147
                            TEXT TO SPEECH




1. Torgersen, Mads (October 27, 2008). "New features in C# 4.0". Microsoft.
   Retrieved 2008-10-28.
2. Naugler, David (May 2007). "C# 2.0 for C++ and Java programmer:
   conference workshop". Journal of Computing Sciences in Colleges 22 (5).
   "Although C# has been strongly influenced by Java it has also been strongly
   influenced by C++ and is best viewed as a descendant of both C++ and Java."
3. Wylie Wong (2002). "Why Microsoft's C# isn't". CNET: CBS Interactive.
   Retrieved 2009-11-14.
     a. "Debugging at Design Time". MSDN. Retrieved 2007-12-31.
     b. http://msdn.microsoft.com/en-us/library/ms171923.aspx
     c. "MSDN TV: Introducing "Cider" - The Visual Studio Designer for WPF
        ("Avalon")". MSDN TV. Retrieved 2008-01-01.
     d. http://www.asp.net/mvc/
     e. http://www.asp.net/DynamicData/
     f. "Team Explorer 2005 (.img file)". Microsoft. Retrieved 2007-03-05.
     g. "Visual Studio Team System 2008 Team Explorer". Microsoft. Retrieved
        2007-03-05.




                                                            148

				
DOCUMENT INFO
Shared By:
Tags:
Stats:
views:53
posted:6/15/2012
language:English
pages:149
Description: software engineering