C#

public class Comanda
            {
                public string id_comanda { get; set; }
                public int pret_total { get; set; }
                public string modalitate_plata { get; set; }
            }

            public class Data
            {
                public int status { get; set; }
                public string status_message { get; set; }
                public Comanda comanda { get; set; }
            }

            public class RootObject
            {
                public Data data { get; set; }
                public bool error { get; set; }
                public List<object> errors { get; set; }
            }

RootObject GetProduse_vars = new System.Web.Script.Serialization.JavaScriptSerializer().Deserialize<RootObject>(text);
                Console.WriteLine(GetProduse_vars.error);

public class ExcelInteropService
{
    private const string EXCEL_CLASS_NAME = "EXCEL7";

    private const uint DW_OBJECTID = 0xFFFFFFF0;

    private static Guid rrid = new Guid("{00020400-0000-0000-C000-000000000046}");

    public delegate bool EnumChildCallback(int hwnd, ref int lParam);

    [DllImport("Oleacc.dll")]
    public static extern int AccessibleObjectFromWindow(int hwnd, uint dwObjectID, byte[] riid, ref Microsoft.Office.Interop.Excel.Window ptr);

    [DllImport("User32.dll")]
    public static extern bool EnumChildWindows(int hWndParent, EnumChildCallback lpEnumFunc, ref int lParam);

    [DllImport("User32.dll")]
    public static extern int GetClassName(int hWnd, StringBuilder lpClassName, int nMaxCount);

    public static Microsoft.Office.Interop.Excel.Application GetExcelInterop(int? processId = null)
    {
        var p = processId.HasValue ? Process.GetProcessById(processId.Value) : Process.Start("excel.exe");
        p.WaitForInputIdle();
        System.Threading.Thread.Sleep(60000);
        Debug.Assert(p != null, "p != null");
        try {
            return new ExcelInteropService().SearchExcelInterop(p);
        }
        catch (Exception) {
            Debug.Assert(p != null, "p != null");
            return GetExcelInterop(p.Id);
        }
    }

    private bool EnumChildFunc(int hwndChild, ref int lParam)
    {
        var buf = new StringBuilder(128);
        GetClassName(hwndChild, buf, 128);
        if (buf.ToString() == EXCEL_CLASS_NAME) { lParam = hwndChild; return false; }
        return true;
    }

    private Microsoft.Office.Interop.Excel.Application SearchExcelInterop(Process p)
    {
        bool timeout = false;
        DateTime start = new DateTime();
        TimeSpan span = new TimeSpan();
        TimeSpan d = new TimeSpan(0, 1, 0);
        Microsoft.Office.Interop.Excel.Window ptr = null;
        int hwnd = 0;
        int hWndParent = 0;
        int hr = -1;

        Debug.Assert(p != null, "p != null");
        try {
            start = DateTime.Now;
            do {
                do {
                    i++;
                    hWndParent = (int)p.MainWindowHandle;
                    if (hWndParent == 0) {
                        Debug.WriteLine("MainWindowNotFound");
                        break;
                    }

                    EnumChildWindows(hWndParent, EnumChildFunc, ref hwnd);
                    if (hwnd == 0) {
                        Debug.WriteLine("ChildWindowNotFound");
                        break;
                    }

                    hr = AccessibleObjectFromWindow(hwnd, DW_OBJECTID, rrid.ToByteArray(), ref ptr);
                    if (hr < 0) {
                        Debug.WriteLine("AccessibleObjectNotFound");
                        break;
                    }
                    if (ptr != null)
                        return ptr.Application;
                } while (ptr == null);
                span = DateTime.Now - start;
                if (span > d)
                    timeout = true;
            } while (timeout == false);
        }
        catch (Exception ex) {
            Debug.Write("Search Exception - ");
            Debug.WriteLine(ex.Message);
            return null;
        }
        try {
            p.CloseMainWindow();
        }
        catch (Exception ex) {
            Debug.Write("CloseWinMain Exception = ");
            Debug.WriteLine(ex.Message);
        }
        return null;
    }
}

myDataTable.Select("Guid IN ('8556c1fd-d4a1-4c1c-b2af-c1fa9403ce4e')")

myDataTable.Select("Guid = '8556c1fd-d4a1-4c1c-b2af-c1fa9403ce4e'")

namespace Compression_Util
{
    class DropBox
    {
        private object sender;
        private EventArgs e;
        private DragEventArgs de;
        private Design zip;
        private string hover;
        private string[] files;
        private string filetype;

        public DropBox(object sender, DragEventArgs de, Design zip, string hover)
        {
            this.sender = sender;
            this.de = de;
            this.zip = zip;
            this.hover = hover;
            this.Hover();
        }

        public DropBox(object sender, EventArgs e, Design zip, string hover)
        {
            this.sender = sender;
            this.e = e;
            this.zip = zip;
            this.hover = hover;
            this.Hover();
        }

        private void InitializeProgressBar(int fileSize)
        {
            zip.DropProgress.Visible = true;
            zip.DropProgress.Minimum = sizeof(Byte);
            zip.DropProgress.Step = sizeof(Byte);
            zip.DropProgress.Maximum = fileSize;
        }

        private void DeInitializeProgressBar()
        {
            zip.DropProgress.Invalidate();
            zip.DropProgress.Visible = false;
        }

        private void IncrementProgressBar()
        {
            zip.DropProgress.PerformStep();
        }

        private void CreateFile(string read, string write)
        {
            try
            {
                FileStream fileStreamReader = new FileStream(read, FileMode.Open, FileAccess.Read);
                FileStream fileStreamWriter = new FileStream(write, FileMode.Create, FileAccess.ReadWrite);
                BinaryReader binaryReader = new BinaryReader(fileStreamReader);
                BinaryWriter binaryWriter = new BinaryWriter(fileStreamWriter);
                int position = 0;
                int length = (int)binaryReader.BaseStream.Length;
                InitializeProgressBar(length);
                while (position < length)
                {
                    Byte line = binaryReader.ReadByte();
                    binaryWriter.Write(line);
                    position += sizeof(Byte);
                    IncrementProgressBar();
                }
                DeInitializeProgressBar();
                binaryWriter.Close();
                binaryReader.Close();
                fileStreamWriter.Close();
                fileStreamReader.Close();
            }
            catch (FileNotFoundException FileEx)
            {
                MessageBox.Show(FileEx.Message);
            }
            catch (Exception Ex)
            {
                MessageBox.Show(Ex.Message);
            }
        }

        private string CreateFileName(string file)
        {
            int i = 0;
            string deleteText = "";
            string newFileName = "";
            while ((i = file.IndexOf('.', i)) != -1)
            {
                deleteText = file.Substring(i);
                i++;
            }
            this.filetype = deleteText;
            //MessageBox.Show(deleteText);
            newFileName = file.Replace(deleteText, ".xxx"); //For Custom Filetype
            return newFileName;
        }
        private void Hover()
        {
            switch (this.hover)
            {
                case "Enter":
                    {
                        zip.DragLabel.Visible = false;
                        zip.DropLabel.Visible = true;
                        zip.BackColor = System.Drawing.Color.DarkGray;
                        zip.DropBox.BackColor = System.Drawing.Color.Thistle;
                        zip.DropBox.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
                        if (de.Data.GetDataPresent(DataFormats.FileDrop, false) == true)
                        {
                            de.Effect = DragDropEffects.All;
                        }
                        break;
                    }
                case "Leave":
                    {
                        zip.DragLabel.Visible = true;
                        zip.DropLabel.Visible = false;
                        zip.BackColor = System.Drawing.Color.WhiteSmoke;
                        zip.DropBox.BackColor = System.Drawing.Color.WhiteSmoke;
                        zip.DropBox.BorderStyle = System.Windows.Forms.BorderStyle.None;
                        break;
                    }
                case "Drop":
                    {
                        zip.DragLabel.Visible = true;
                        zip.DropLabel.Visible = false;
                        zip.BackColor = System.Drawing.Color.WhiteSmoke;
                        zip.DropBox.BackColor = System.Drawing.Color.WhiteSmoke;
                        zip.DropBox.BorderStyle = System.Windows.Forms.BorderStyle.None;
                        this.Drop();
                        break;
                    }
            }
        }
        private void Drop()
        {
            this.files = (string[])this.de.Data.GetData(DataFormats.FileDrop);
            foreach (string file in files)
            {
                //MessageBox.Show(file);
                string newFileName = this.CreateFileName(file);
                //MessageBox.Show(newFileName);
                if (!File.Exists(newFileName))
                {
                    this.CreateFile(file, newFileName);
                }
                else
                {
                    MessageBoxButtons buttons = MessageBoxButtons.YesNo;
                    DialogResult result;
                    string message = "File already exists, Overwrite?";
                    string caption = "";
                    result = MessageBox.Show(zip, message, caption, buttons);
                    switch (result)
                    {
                        case DialogResult.Yes:
                            {
                                this.CreateFile(file, newFileName);
                                break;
                            }
                        case DialogResult.No:
                            {
                                MessageBox.Show("Operation has been cancelled!");
                                break;
                            }
                        default: break;
                    }
                }
            }
        }
    }
}