- Table of Contents
- .NET Book Recommendations
- What Is .NET?
- The Microsoft .NET Framework
- The Common Language Runtime (CLR), the Common Type System (CTS), and the Common Language Specification (CLS)
- .NET Framework Class Library
- Visual Studio .NET
- .NET Enterprise Servers and .NET My Services
- .NET Compliant Languages
- C#
- Visual Basic .NET (VB .NET)
- ASP.NET
- XML Web Services
- ADO.NET
- XML.NET
- Windows Forms
- Why .NET?
- Displaying Errors with the Error Provider
- COM Interoperability
- Comparing Java and .NET
- Calling Unmanaged Code
- .NET Application Security
- Code Access Security
- .NET Standards Support
- Numeric Types in the .NET Framework
- Working with Strings
- Formatting Strings
- Trimming Character Strings
- Comparing Strings in .NET 2.0
- Arrays and Collections
- Arrays as Class Members
- Sorting a Multi-Dimensional Array
- Sorting a Multi-Dimensional Array with LINQ
- File I/O (System.IO)
- Working with File Names
- Using the File System
- Working with Files and Directories
- Monitoring the File System
- Working with Streams
- Working with Text Encodings
- Working with Date and Time
- Extending the DateTime Class
- Fun with Dates
- Exceptions
- Delegates
- Events
- Asynchronous Programming
- Asynchronous File I/O
- Timers
- Random Numbers
- Cryptographically Secure Random Numbers
- Serialization
- MultiThreading (System.Threading)
- Multi-Threading Overview
- The Managed Thread Pool
- Managed Threading
- Thread Synchronization
- Synchronizing Data Access
- Trace Debugging
- Tracing in .NET 2.0
- ASP.NET Trace
- Validating User Input in ASP.NET Web Pages
- Event Logging
- Monitoring Application Performance
- Accessing the Registry
- Accessing Environment Information
- Environment Variables in .NET 2.0
- Managing Windows Forms Applications
- Working with Email
- Working with Graphics
- Animating a Background
- Working with Images
- Drawing Cycloid Curves
- Simulating the Spirograph
- Building International Web Applications
- .NET Compact Framework
- Mobile Web Development with ASP.NET
- Speech Technologies
- Microsoft MapPoint Web Service
- Working with Typed DataSets
- Using Relationships in DataSets
- DataColumn Expressions
- Playing Simple Sounds
- Playing Sounds with .NET 2.0
- Returning an Image in a Web Page
- RSS
- Best Practices Project Structure
- Best Practices Application Blocks
- The Data Access Application Block
- The Exception Management Application Block
- Best Practices — Performance
- Best Practices — Performance and Scalability
- Best Practices - Testing
- Reading the Tea Leaves, 2005
- Predictions: A Look Back at 2005, and a Look Ahead to 2006
- .NET Downloads
- Application Deployment Overview
- Application Deployment — Versioning
- Application Deployment — Version Policy
- Application Deployment — Packaging and Distribution
- .NET Remoting Overview
- A Remoting Demonstration
- Remoting Configuration
- Remoting: Lifetimes and Leases
- Remoting: Other Issues
- Attributes
- Writing Custom Attributes
- Accessing Attributes in Code
- Reflection
- Class Design: Inheritance, Interface, or Composition?
- The TriTryst Game
- Console Applications in .NET 2.0
- New File I/O Methods in .NET 2.0
- Building Projects with MSBuild
- Unmanaged Callbacks in .NET 2.0
- Timer Troubles
- Non-Rectangular Windows Forms
- Windows Forms Transparency
- 10 Things I Hate About Visual Basic
- 10 Things I Hate About C#
- Background Processing with Idle Time
- Scaling Windows Forms
- Reading and Writing Binary Data
- New Memory Management Functions in .NET 2.0
- Compatibility Between .NET 1.1 and .NET 2.0
- Managed Debugging Assistants in .NET 2.0
- XDir: A Program for Viewing Directory Sizes
- The Microsoft.VisualBasic Namespace
- Operator Overloading
- Working with GPS Data
- Hidden Visual Studio Tools
- .NET 3.0
- The .NET 2.0 Stopwatch Class
- Nullable Types
- Drawing Rotated Text
- Unsafe Code
- Other .NET Languages
- Compiler Directives
- Safe Handles
- Predictions, 2007 Edition
- New Features in C# 3.0
- Generics
- Network Client Programming
- On the Misuse of Exceptions
- Maximum Object Size in .NET
- More on Maximum Object Sizes
- Keyed Collection Memory Limitations
- Matching String Endings
- Allocating Small Data Structures
- Grumbling About Limitations
- Some Thoughts on the Nature of What We Do
- Working with Predicates in Collections
- Working with DataReaders
- Outputting XML with XmlWriter
- Writing XML Data
- Working with Compression
- Another Look at Compressed Streams
- Compressing a Very Large File
- Canonical URIs
- Constructing URIs
- Using OneWayAttribute for Remote Calls
- Selecting a Garbage Collector
- Linked List
- Linked List Application - The MRU List
- Auto-implemented Properties in C#
- The HashSet Collection
- Looking Ahead: 2018
- An Experiment in Optimization
- A Larger Integer
- Extension Methods
- Language Integrated Query (LINQ)
- Variable Length Parameter Lists
- The ReaderWriterLockSlim Synchronization Primitive
- Sorting a Text File
- Sorting a Large Text File
- Using ListView with Large Data Sets
- LINQ One-Liners
- Regular Expression Optimization
- Random File I/O
- Computing the Size of a Structure
- More on Computing Structure Sizes
- UnmanagedMemoryStream
- Dynamically Loading Code
- Building a String Table
- Delegates Versus Function Pointers
- Visual Studio Editor Features
- A Simple Profile Timer
- New Features in C# 4.0
- IEnumerator or IList?
- New Features in .NET 4.0
- Set Operations with IEnumerable and HashSet
- Using File Locks
- Extending Object Functionality
- Clearing a HashSet
- When Hash Codes Matter
- Parsing Command Line Options
- Creating a Single-Instance Program
- Asynchronous Windows Forms Events
- The BackgroundWorker Component
- Fixing a Dumb Mistake
- Thinking About Multi-Threaded Programs
- JavaScript Object Notation
- Useful .NET-related Sites
- Markov Models
- Building an Order 0 Markov Model
- Higher Order Markov Models
- Webmaster's Guide to robots.txt
- An Overview of the Parallel Extensions to .NET
- Parallel Extensions Synchronization Objects
- Thread Safe Collections
- A Bug and a Conundrum
- Another Bug and an Answer
- Task Parallel Library
- Good and Bad Ideas in C#
- Parallel LINQ
- Copying Large Files
- Replacing File.Copy
- Learning from Our Mistakes
- Symbolic Links
- There Is No Easy Fix
- Tracking Hurricanes
- Examining Hurricane Data
- Searching for Multiple Strings
- Simple JSON Processing
- Aho-Corasick String Searching
- Writing a Web Crawler
- Web Crawler Politeness
- Source Control Management
- Subversion
- Communicating with Datagrams
- Fun with Actions and Funcs New
- The Future of Media
- The Importance of Metadata
- Of Comparison and IComparer
- IComparer, Comparer, IComparable, Oh My!
- Comparing Generic Types New
- A Simple HTTP Server New
- Informit Reference Library
Playing Simple Sounds
Last updated Nov 4, 2004.
Playing Simple Sounds
Over the years, sound has become an important part of many applications. Surprisingly, the .NET Framework does not include a class that implements playing sounds, although you can call the Beep function (Microsoft.VisualBasic.Beep()) if you just want to make a simple noise. If you want to play other types of sounds, you have to dive into the Windows API. There are several different ways to play sounds, and the way you choose will depend on how rich you want your sound support to be. This entry will discuss the simplest way: using the PlaySound function.
About PlaySound
PlaySound is one function in a fairly large API set called the Waveform Audio Interface, which in turn is part of the Windows Multimedia interface. With the exception of the sndPlaySound function, which implements a subset of PlaySound functionality, the other functions in the Waveform Audio Interface present a very low-level method of playing sounds. Those functions (which all have the wave prefix) are very handy if you want to mix sounds and have very tight control over what gets played and when, but they're overkill if all you want is to play a simple sound. If you're interested in learning more about using the wave functions, you should read the article Recording and Playing Sound with the Waveform Audio Interface.
PlaySound is defined in the Windows API like this:
BOOL PlaySound(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound);
The corresponding .NET managed prototypes for this function are:
[C#]
[DllImport("winmm.dll")]
public extern static bool PlaySound(
string pszName, IntPtr hModule, int dwFlags);
[Visual Basic]
<DllImport("winmm.dll")> Public Shared Function PlaySound( _
ByVal pszName As String, ByVal hModule As IntPtr, _
ByVal dwFlags As Integer) As Boolean
End Function
The first parameter to PlaySound is normally the name of the sound file that you want to play. PlaySound only plays waveform audio files (.WAV). This parameter can also be interpreted as an alias for a system event, a resource identifier, or even a pointer to a .WAV file that has been loaded into memory. In this section, we'll concentrate on the parameter being used as a file name.
If the first parameter is a resource identifier, then the second parameter, hModule is used to pass the handle of the executable file that contains the resource. Since we won't be loading sounds from resources here, we'll pass IntPtr.Zero as the second parameter.
The third parameter is the ubiquitous "flags" parameter that all too many Windows API functions use. This is a bitmapped value that specifies how the first parameter is to be interpreted, and also how the system should play the sound. As you will see below, you can select a number of different options with this parameter.
The Windows API header files define the different flags values as constants that have the SND_ prefix. In .NET programs, that sort of thing is more commonly expressed as an enumeration, like this:
[C#]
[Flags]
public enum SoundFlags
{
SndApplication = 0x80, // look for application specific association
SndAlias = 0x10000, // name is a WIN.INI [sounds] entry
SndAliasId = 0x110000, // name is a WIN.INI [sounds] entry
SndAsync = 0x1, // play asynchronously
SndFilename = 0x20000, // lpszSoundName is a file name
SndLoop = 0x8, // loop the sound until stopped
SndMemory = 0x4, // lpszSoundName points to a memory file
SndNoDefault = 0x2, // Do not play default sound if sound file not found
SndNoStop = 0x10, // Do not stop currently playing sound
SndNoWait = 0x2000, // Do not wait if sound is currently playing
SndPurge = 0x40, // purge non-static events for task
SndResource = 0x40004, // lpszSoundName is a resource name or atom
SndSync = 0x0 // play synchronously (default)
}
[Visual Basic]
<Flags()> Public Enum SoundFlags SndApplication = &H80 ' look for application specific association SndAlias = &H10000 ' name is a WIN.INI [sounds] entry SndAliasId = &H110000 ' name is a WIN.INI [sounds] entry SndAsync = &H1 ' play asynchronously SndFilename = &H20000 ' lpszSoundName is a file name SndLoop = &H8 ' loop the sound until stopped SndMemory = &H4 ' lpszSoundName points to a memory file SndNoDefault = &H2 ' Do not play default sound if sound file not found SndNoStop = &H10 ' Do not stop currently playing sound SndNoWait = &H2000 ' Do not wait if sound is currently playing SndPurge = &H40 ' purge non-static events for task SndResource = &H40004 ' lpszSoundName is a resource name or atom SndSync = &H0 ' play synchronously (default) End Enum
Note that the enumeration has the Flags attribute applied so that the values can be combined using an arithmetic "or" operation.



Account Sign In
View your cart