C#

Nadia Monalisa wrote:

Is it more memory efficient to work with IQueryable object instead of IEnumerable object ?

dasblinkenlight wrote:

IQueryable pushes the query logic into RDBMS, while IEnumerable does things in the main memory

dasblinkenlight wrote:

one for communicating with programmers who read your code

dasblinkenlight wrote:

In case of LINQ to SQL, this means pushing the query logic into RDBMS

// 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