C#

DataRow[] returnRows = DS.Tables[0].Select("TestDescription='" + search + "'");

private void BtnSearch_Click(object sender, RoutedEventArgs e)
        {
            string ConnectionString = "Data Source=RATTLERR;Initial Catalog=medical;Integrated Security=True;";
            

            SqlConnection conn = new SqlConnection(ConnectionString);
            SqlDataAdapter dAdapter = new SqlDataAdapter("Select * FROM test", conn);
            
            conn.Open();
          
            DataSet DS = new DataSet();
            string search = tbSearch.Text;
            int result = 0;

            if (tbSearch.Text.Length >= 1)
            {
                

                dAdapter.Fill(DS);
                DataRow[] returnRows = DS.Tables[0].Select("TestDescription='" + search + "'");
                result = returnRows.Length;

                if (result > 0)
                {
                    dgInfo.ItemsSource = returnRows.CopyToDataTable().DefaultView;

                }
                else
                {
                    System.Windows.MessageBox.Show("No Records Found");
                }
                conn.Close();
                }
            }

Quote:

Whoops!
There was a problem displaying this image.
Retrying...

SmtpClient smtpClient = new SmtpClient();
               NetworkCredential basicCredential = new NetworkCredential("myliveaccount@live.com", "mylivepass");
               MailMessage message = new MailMessage();
               MailAddress fromAddress = new MailAddress("myliveaccount@live.com");

               // setup up the host, increase the timeout to 5 minutes
               smtpClient.Host = "smtp.live.com";
               smtpClient.UseDefaultCredentials = false;
               smtpClient.Credentials = basicCredential;
               smtpClient.Timeout = (60 * 5 * 1000);
               smtpClient.EnableSsl = true;

               message.From = fromAddress;
               message.Subject = "subject";

               message.IsBodyHtml = false;
               message.Body = "#Tag1 #Tag2 #Tag3 #Tag4";
               message.To.Add("tumblrblogemail@tumblr.com");

               string attachmentFilename = @"C:\0103150633034149.jpg";
               Attachment attachment = new Attachment(attachmentFilename, MediaTypeNames.Application.Octet);
               ContentDisposition disposition = attachment.ContentDisposition;
               disposition.CreationDate = File.GetCreationTime(attachmentFilename);
               disposition.ModificationDate = File.GetLastWriteTime(attachmentFilename);
               disposition.ReadDate = File.GetLastAccessTime(attachmentFilename);
               disposition.FileName = Path.GetFileName(attachmentFilename);
               disposition.Size = new FileInfo(attachmentFilename).Length;
               disposition.DispositionType = DispositionTypeNames.Attachment;
               message.Attachments.Add(attachment);

               smtpClient.Send(message);

MaximumChangeJournalRecordSize =
    ( (MaximumComponentLength - 1) * sizeof(WCHAR)
    + sizeof(USN_RECORD_V3) );

// ENUM USN DATA

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;

public class Win32
{
    /// <summary>
    /// Represents an update sequence number (USN) change journal, its records, and its capacity.
    /// This structure is the output buffer for the FSCTL_QUERY_USN_JOURNAL control code.
    /// Minimum supported client: Windows XP [desktop apps only]
    /// Minimum supported server: Windows Server 2003 [desktop apps only]
    /// </summary>
    /// <see cref="http://msdn.microsoft.com/en-us/library/windows/desktop/aa365721%28v=vs.85%29.aspx"/>
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USN_JOURNAL_DATA_V0
    {
        public UInt64 UsnJournalId;
        public Int64 FirstUsn;
        public Int64 NextUsn;
        public Int64 LowestValidUsn;
        public Int64 MaxUsn;
        public UInt64 MaximumSize;
        public UInt64 AllocationDelta;
    }

    /// <summary>
    /// Represents an update sequence number (USN) change journal, its records, and its capacity.
    /// This structure is the output buffer for the FSCTL_QUERY_USN_JOURNAL control code.
    /// Minimum supported client: Windows 8 [desktop apps only]
    /// Minimum supported server: Windows Server 2012 [desktop apps only]
    /// </summary>
    /// <see cref="http://msdn.microsoft.com/en-us/library/windows/desktop/hh802707%28v=vs.85%29.aspx"/>
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USN_JOURNAL_DATA_V1
    {
        public UInt64 UsnJournalId;
        public Int64 FirstUsn;
        public Int64 NextUsn;
        public Int64 LowestValidUsn;
        public Int64 MaxUsn;
        public UInt64 MaximumSize;
        public UInt64 AllocationDelta;
        public UInt16 MinSupportedMajorVersion;
        public UInt16 MaxSupportedMajorVersion;
    }

    /// <summary>
    /// Contains the information for an update sequence number (USN) change journal version 3.0 record. The version 2.0 record is defined by the USN_RECORD_V2 structure (also called USN_RECORD structure).
    /// </summary>
    /// <see cref="http://msdn.microsoft.com/en-us/library/windows/desktop/hh802708%28v=vs.85%29.aspx"/>
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct USN_RECORD_V3
    {
        public UInt32 RecordLength;
        public UInt16 MajorVersion;
        public UInt16 MinorVersion;
        public Byte FileReferenceNumber;
        public Byte ParentFileReferenceNumber;
        public Int64 Usn;
        public FILETIME TimeStamp;
        public UInt32 Reason;
        public UInt32 SourceInfo;
        public UInt32 SecurityId;
        public UInt32 FileAttributes;
        public UInt16 FileNameLength;
        public UInt16 FileNameOffset;
        public Char FileName;
    }

    /// <summary>
    /// Contains information defining the boundaries for and starting place of an enumeration of update sequence number (USN) change journal records for ReFS volumes. It is used as the input buffer for the FSCTL_ENUM_USN_DATA control code.
    /// </summary>
    /// <see cref="http://msdn.microsoft.com/en-us/library/windows/desktop/hh802704%28v=vs.85%29.aspx"/>
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct MFT_ENUM_DATA_V1
    {
        public UInt64 StartFileReferenceNumber;
        public Int64 LowUsn;
        public Int64 HighUsn;
        public UInt16 MinMajorVersion;
        public UInt16 MaxMajorVersion;
    }

    /// <summary>
    /// Sends the 'dwIoControlCode' to the device specified by 'hDevice'.
    /// </summary>
    /// <param name="hDevice">IntPtr handle to handle to a file, directory, or device to receive 'dwIoControlCode'. Obtained by calling CreateFile.</param>
    /// <param name="dwIoControlCode">Device IO Control Code to send</param>
    /// <param name="lpInBuffer">Input buffer if required</param>
    /// <param name="nInBufferSize">Size of input buffer</param>
    /// <param name="lpOutBuffer">Output buffer if required</param>
    /// <param name="nOutBufferSize">Size of output buffer</param>
    /// <param name="lpBytesReturned">Number of bytes returned in output buffer</param>
    /// <param name="lpOverlapped">IntPtr to an 'OVERLAPPED' structure</param>
    /// <returns>'true' if successful, otherwise 'false'</returns>
    /// <see cref="http://msdn.microsoft.com/en-us/library/windows/desktop/aa363216%28v=vs.85%29.aspx"/>
    [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true, CharSet = CharSet.Auto)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool DeviceIoControl(
        SafeHandle hDevice,
        UInt32 dwIoControlCode,
        IntPtr lpInBuffer,
        UInt32 nInBufferSize,
        out IntPtr lpOutBuffer,
        UInt32 nOutBufferSize,
        out UInt32 lpBytesReturned,
        IntPtr lpOverlapped
    );

    [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true, CharSet = CharSet.Auto)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool DeviceIoControl(
        SafeHandle hDevice,
        UInt32 dwIoControlCode,
        IntPtr lpInBuffer,
        UInt32 nInBufferSize,
        out USN_JOURNAL_DATA_V1 lpOutBuffer,
        UInt32 nOutBufferSize,
        out UInt32 lpBytesReturned,
        IntPtr lpOverlapped
    );

    [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true, CharSet = CharSet.Auto)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool DeviceIoControl(
        SafeHandle hDevice,
        UInt32 dwIoControlCode,
        ref MFT_ENUM_DATA_V1 lpInBuffer,
        UInt32 nInBufferSize,
        out USN_RECORD_V3 lpOutBuffer,
        UInt32 nOutBufferSize,
        out UInt32 lpBytesReturned,
        IntPtr lpOverlapped
    );

    // Use interop to call the CreateFile function. 
    // For more information about CreateFile, 
    // see the unmanaged MSDN reference library.
    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    public static extern SafeFileHandle CreateFile(
        string lpFileName,
        uint dwDesiredAccess,
        uint dwShareMode,
        IntPtr lpSecurityAttributes,
        uint dwCreationDisposition,
        uint dwFlagsAndAttributes,
        IntPtr hTemplateFile
    );

    /// <summary>
    /// Sets the number of bytes specified by 'size' of the memory associated with the argument 'ptr' 
    /// to zero.
    /// </summary>
    /// <param name="ptr"></param>
    /// <param name="size"></param>
    [DllImport("kernel32.dll")]
    public static extern void ZeroMemory(IntPtr ptr, int size);
}

namespace UsnTest01
{

    class Program
    {
        #region constants
        public const short FILE_ATTRIBUTE_NORMAL = 0x80;
        public const short INVALID_HANDLE_VALUE = -1;
        public const UInt32 GENERIC_READ = 0x80000000;
        public const UInt32 GENERIC_WRITE = 0x40000000;
        public const UInt32 FILE_SHARE_READ = 0x00000001;
        public const UInt32 FILE_SHARE_WRITE = 0x00000002;
        public const UInt32 CREATE_NEW = 1;
        public const UInt32 CREATE_ALWAYS = 2;
        public const UInt32 OPEN_EXISTING = 3;

        private const UInt32 FILE_DEVICE_FILE_SYSTEM = 0x00000009;
        private const UInt32 METHOD_NEITHER = 3;
        private const UInt32 METHOD_BUFFERED = 0;
        private const UInt32 FILE_ANY_ACCESS = 0;
        private const UInt32 FILE_SPECIAL_ACCESS = 0;
        private const UInt32 FILE_READ_ACCESS = 1;
        private const UInt32 FILE_WRITE_ACCESS = 2;
        public const UInt32 FSCTL_QUERY_USN_JOURNAL = (FILE_DEVICE_FILE_SYSTEM << 16) | (FILE_ANY_ACCESS << 14) | (61 << 2) | METHOD_BUFFERED;
        public const UInt32 FSCTL_ENUM_USN_DATA = (FILE_DEVICE_FILE_SYSTEM << 16) | (FILE_ANY_ACCESS << 14) | (44 << 2) | METHOD_NEITHER;
        public const UInt32 FSCTL_READ_USN_JOURNAL = (FILE_DEVICE_FILE_SYSTEM << 16) | (FILE_ANY_ACCESS << 14) | (46 << 2) | METHOD_NEITHER;
        #endregion constants

        static void Main(string[] args)
        {

            // GET VOLUME HANDLE

            SafeFileHandle handleValue = null;
            handleValue = Win32.CreateFile(
                @"\\.\C:",
                GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
                IntPtr.Zero,
                OPEN_EXISTING,
                0,
                IntPtr.Zero);

            if (handleValue.IsInvalid)
            {
                Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
            }

            // GET USN JOURNAL ID

            Win32.USN_JOURNAL_DATA_V1 ujd = new Win32.USN_JOURNAL_DATA_V1();
            uint lpBytesReturned;

            bool retJournalId = Win32.DeviceIoControl(
                handleValue,
                FSCTL_QUERY_USN_JOURNAL,
                IntPtr.Zero,
                0,
                out ujd,
                (uint)Marshal.SizeOf(ujd),
                out lpBytesReturned,
                IntPtr.Zero);

            Console.WriteLine("Wert ist " + ujd.UsnJournalId.ToString("X4"));



            // ENUM USN DATA

            Win32.USN_RECORD_V3 usnRecordV3;
            Win32.MFT_ENUM_DATA_V1 mftEnumDataV1 = new Win32.MFT_ENUM_DATA_V1 { StartFileReferenceNumber = 0 };

            //int mftEnumDataV1BufferSize = Marshal.SizeOf(mftEnumDataV1);
            //IntPtr mftEnumDataV1BufferPointer = Marshal.AllocHGlobal(mftEnumDataV1BufferSize);
            //Marshal.StructureToPtr(mftEnumDataV1, mftEnumDataV1BufferPointer, true);
            //Win32.ZeroMemory(mftEnumDataV1BufferPointer, mftEnumDataV1BufferSize);

            // TODO "255-1" durch "MaximumComponentLength-1" ersetzen
            uint outBufferSize = (uint)((255 - 1) * sizeof(Char) + Marshal.SizeOf(typeof(Win32.USN_RECORD_V3)));
            lpBytesReturned = 0;

            bool retUsnData = false;
            while (retUsnData != true) // while non-zero value
            {
                retUsnData = Win32.DeviceIoControl(
                    handleValue,
                    FSCTL_ENUM_USN_DATA,
                    ref mftEnumDataV1,
                    (uint)Marshal.SizeOf(mftEnumDataV1),
                    out usnRecordV3,
                    175, //max without exception is 175. Should be var `outBufferSize`.
                    out lpBytesReturned,
                    IntPtr.Zero);

                //mftEnumDataV1.StartFileReferenceNumber = usnRecordV3.RecordLength;
                //object test = Marshal.PtrToStructure(mftEnumDataV1BufferPointer, typeof(Win32.MFT_ENUM_DATA_V1));
                //Marshal.WriteInt64(mftEnumDataV1BufferPointer, usnRecordV3.RecordLength);
                //Marshal.StructureToPtr(mftEnumDataV1, mftEnumDataV1BufferPointer, true);

            }

            int r1 = Marshal.GetLastWin32Error();
            int r2 = Marshal.GetHRForLastWin32Error();

            if (retUsnData == false)
            {
                Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
            }

        }
    }
}

if (value % 2 == 0) { x++; break; }
if (value % i == 0) { x++; break; }