C#

// WAVEFORMATEX.cs
using System.Runtime.InteropServices;

// http://msdn.microsoft.com/en-us/library/dd757713(v=VS.85).aspx
/*
typedef struct {
  WORD  wFormatTag;
  WORD  nChannels;
  DWORD nSamplesPerSec;
  DWORD nAvgBytesPerSec;
  WORD  nBlockAlign;
  WORD  wBitsPerSample;
  WORD  cbSize;
} WAVEFORMATEX;
*/
[StructLayout(LayoutKind.Sequential)]
internal struct WAVEFORMATEX
{
    public short wFormatTag;
    public short nChannels;
    public int nSamplesPerSec;
    public int nAvgBytesPerSec;
    public short nBlockAlign;
    public short wBitsPerSample;
    public short cbSize;
}

// NativeMethods.cs
using System;
using System.Runtime.InteropServices;

// http://msdn.microsoft.com/en-us/library/dd743869(v=VS.85).aspx
/*
void CALLBACK waveOutProc(
HWAVEOUT hwo,
UINT uMsg,
DWORD_PTR dwInstance,
DWORD_PTR dwParam1,
DWORD_PTR dwParam2
);
*/
internal delegate void waveOutProc(
    IntPtr hwo,
    int uMsg,
    IntPtr dwInstance,
    IntPtr dwParam1,
    IntPtr dwParam2);

// http://msdn.microsoft.com/en-us/library/dd743833(v=VS.85).aspx
internal static class NativeMethods
{
    public const int MMSYSERR_NOERROR = 0;
    public const int CALLBACK_FUNCTION = 0x00030000;

    // http://msdn.microsoft.com/en-us/library/dd743866(v=VS.85).aspx
    /*
MMRESULT waveOutOpen(
LPHWAVEOUT phwo,
UINT_PTR uDeviceID,
LPWAVEFORMATEX pwfx,
DWORD_PTR dwCallback,
DWORD_PTR dwCallbackInstance,
DWORD fdwOpen
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutOpen(
        out IntPtr phwo,
        int uDeviceID,
        ref WAVEFORMATEX pwfx,
        waveOutProc dwCallback,
        IntPtr dwCallbackInstance,
        int fdwOpen);

    // http://msdn.microsoft.com/en-us/library/dd743856(v=VS.85).aspx
    /*
MMRESULT waveOutClose(
HWAVEOUT hwo
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutClose(IntPtr hwo);

    // http://msdn.microsoft.com/en-us/library/dd743864(v=VS.85).aspx
    /*
MMRESULT waveOutGetVolume(
HWAVEOUT hwo,
LPDWORD pdwVolume
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutGetVolume(
        IntPtr hwo,
        out uint pdwVolume);

    // http://msdn.microsoft.com/en-us/library/dd743874(v=VS.85).aspx
    /*
MMRESULT waveOutSetVolume(
HWAVEOUT hwo,
DWORD dwVolume
);
     */
    [DllImport("winmm.dll", SetLastError = true)]
    public static extern int waveOutSetVolume(
        IntPtr hwo,
        uint dwVolume);
}

// WaveOut.cs
using System;

/// <summary>
/// WaveOut API wrapper
/// </summary>
public class WaveOut : IDisposable
{
    private waveOutProc callback;
    private IntPtr handle;
    private int id;

    public WaveOut(int id)
    {
        callback = new waveOutProc(Callback);
        this.id = id;
    }
    ~WaveOut()
    {
        Dispose(false);
    }

    public int ID
    {
        get { return id; }
    }

    private void Callback(IntPtr hwo, int uMsg, IntPtr dwInstance,
        IntPtr dwParam1, IntPtr dwParam2)
    {
        // check and handle uMsg here
    }
    public void Close()
    {
        if (handle != IntPtr.Zero)
            NativeMethods.waveOutClose(handle);
        handle = IntPtr.Zero;
    }
    public void Dispose()
    {
        Dispose(true);
        // not calling GC.SuppressFinalize(this); so object can be recreated by calling Open();
    }
    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // dispose managed resources
        }
        if (handle != IntPtr.Zero)
            Close();
    }
    public uint GetVolume()
    {
        uint volume = uint.MaxValue;
        if (handle != IntPtr.Zero)
            NativeMethods.waveOutGetVolume(handle, out volume);
        return volume;
    }
    public void Open()
    {
        if (handle == IntPtr.Zero)
        {
            WAVEFORMATEX waveFormatEx = new WAVEFORMATEX();
            // CD quality: 2 channel, 44.1KHz 16 bit, PCM
            waveFormatEx.wFormatTag = 1;
            waveFormatEx.nChannels = 2;
            waveFormatEx.nSamplesPerSec = 44100;
            waveFormatEx.wBitsPerSample = 16;
            waveFormatEx.nBlockAlign = (short)(waveFormatEx.nChannels * (waveFormatEx.wBitsPerSample / 8));
            waveFormatEx.nAvgBytesPerSec = waveFormatEx.nSamplesPerSec * waveFormatEx.nBlockAlign;
            NativeMethods.waveOutOpen(out handle, id,
                ref waveFormatEx, callback, IntPtr.Zero,
                NativeMethods.CALLBACK_FUNCTION);
        }
    }
    public void SetVolume(uint volume)
    {
        if (handle != IntPtr.Zero)
            NativeMethods.waveOutSetVolume(handle, volume);
    }
}

// Test.cs
using System;

internal class Test
{
    private static void ConvertFromVolume(uint volume, out int left, out int right)
    {
        left = (int)volume & 0xFFFF;
        right = (int)(volume >> 16) & 0xFFFF;
    }
    private static uint ConvertToVolume(int left, int right)
    {
        return (uint)right << 16 | (ushort)left;
    }
    public void Run()
    {
        // First device wil have ID of 0
        WaveOut waveOut = new WaveOut(0);

        // Open device
        waveOut.Open();

        // Get and save current volume
        int originalLeft;
        int originalRight;
        ConvertFromVolume(waveOut.GetVolume(), out originalLeft, out originalRight);
        // Write values
        Console.WriteLine(
            "Left: {0}, Right: {1}",
            originalLeft, originalRight);

        // Set new volume
        int newLeft = 32768;
        int newRight = 32768;
        waveOut.SetVolume(ConvertToVolume(newLeft, newRight));

        // Get and write values
        ConvertFromVolume(waveOut.GetVolume(), out newLeft, out newLeft);
        Console.WriteLine(
            "Left: {0}, Right: {1}",
            newLeft, newLeft);

        // Reset to original
        waveOut.SetVolume(ConvertToVolume(originalLeft, originalRight));

        // Get and write values
        ConvertFromVolume(waveOut.GetVolume(), out newLeft, out newLeft);
        Console.WriteLine(
            "Left: {0}, Right: {1}",
            newLeft, newLeft);

        // Close device
        waveOut.Close();
    }
}

// Program.cs
using System;

class Program
{
    static void Main(string[] args)
    {
        new Test().Run();

        // Pause
        Console.ReadKey();
    }
}

MacRaider4 wrote:

I'm probably missing something obvious

public BGW()
  {
    this.WorkerReportsProgress = true;
    this.WorkerSupportsCancellation = true;
  }

private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    pgbWrite.Value = e.ProgressPercentage;
    lblCurrentCount.Text = e.UserState.ToString();
}

percentComplete = (int)((float)currentMail / (float)intEmail * 100);
if (percentComplete <= highestPercentageReached)
{
    if (percentComplete == 0)
    {
        percentComplete = 1;
    }
    highestPercentageReached = percentComplete + 1;
    string strCounter = currentMail + " of " + intEmail;
    //backgroundWorker1.ReportProgress(percentComplete, strCounter);
    BGWs[0].ReportProgress(percentComplete, strCounter);
}

protected override void OnDoWork(DoWorkEventArgs e)
{
  base.OnDoWork(e);
  WriteMail.WriteAndParseMail(this);
}

highestPercentageReached = percentComplete + 1;
string strCounter = currentMail + " of " + intEmail;
(sender as BackgroundWorker).ReportProgress(percentComplete, strCounter);

MacRaider4 wrote:

(as if it were a bgw perhaps in a thread you can use the variable directally)?

MacRaider4 wrote:

Plus when I was getting into more advanced someone reccomended keeping as little as you can on your main form and using classes for as much as possible. Is this a good habbit, bad habbit or just personal preference?

// This can go in a static class somewhere
public static void SendMessagesAsync(ProgressChangedHandler progressCallback, params SomeClass[] messages)
{
  for (int idx = 0; idx < messages.Length; idx++)
  {
    BackgroundWorker wkr = new BackgroundWorker();
    wkr.WorkerSupportsProgress = true;
    wkr.ProgressChanged += progressCallback;  // This will go back to your main form and display something
    wkr.DoWorkEventArgs += wkr_DoWork;  // This is inside the same static class, below, not part of its public interface
    wkr.RunWorkerAsync(messages[idx]);
  }
}

// All of your workers can use the same DoWork, as long as they're given different arguments
private static void wkr_DoWork(object sender, DoWorkEventArgs e)
{
  BackgroundWorker wkr = sender as BackgroundWorker; // Use this to report progress
  SomeClass args = e.Argument as SomeClass;  // Here's any info you need to pass to the worker

  // ... Do your processing here ... WriteMail, or whatever
}

// And on your form...

private void SomethingCalledFromYourForm()
{
  MyStaticClass.SendMessagesAsync(wkr_ProgressChanged, new SomeClass[] {
    new SomeClass() { Whatever = parameters, YouWant = toset },
    new SomeClass() { Subject = someone, Body = "something else?", Recipient = "someone@somewhere.sometime" }
  });
}

Ian Shlasko wrote:

I wonder if the BackgroundWorker only allows ReportProgress to be called during the DoWork

public void ReportProgress(int percentProgress, object userState)
{
    if (!this.WorkerReportsProgress)
    {
        throw new InvalidOperationException(SR.GetString("BackgroundWorker_WorkerDoesntReportProgress"));
    }
    ProgressChangedEventArgs arg = new ProgressChangedEventArgs(percentProgress, userState);
    if (this.asyncOperation != null)
    {
        this.asyncOperation.Post(this.progressReporter, arg);
    }
    else
    {
        this.progressReporter(arg);
    }
}