Logos Bible Software Code Blog

    Rect rect = new Rect(1.5, 2, 3.5, 4);
    string s;

    s = rect.ToString(); // "1.5,2,3.5,4"
    Rect.Parse(s); // success

    Thread.CurrentThread.CurrentCulture = new CultureInfo("de"); // or "es", "fr", etc.

    s = rect.ToString(); // "1,5;2;3,5;4"
    Rect.Parse(s); // throws FormatException

    s = rect.ToString(CultureInfo.InvariantCulture);
    Rect.Parse(s); // success

    internal static class NativeMethods
    {
        [DllImport("XpsPrint.dll", ExactSpelling = true, CharSet = CharSet.Unicode)]
        public static extern int StartXpsPrintJob(string printerName, string jobName, string outputFileName, IntPtr progressEvent,
        SafeWaitHandle completionEvent, [MarshalAs(UnmanagedType.LPArray)] byte[] printablePagesOn, int printablePagesOnCount,
        out IXpsPrintJob xpsPrintJob, out IXpsPrintJobStream documentStream, out IXpsPrintJobStream printTicketStream);
    }

    [ComImport, Guid("E974D26D-3D9B-4D47-88CC-3872F2DC3585"), ClassInterface(ClassInterfaceType.None)]
    internal class XpsOMObjectFactory
    {
    }

    [ComImport, Guid("F9B2A685-A50D-4FC2-B764-B56E093EA0CA"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IXpsOMObjectFactory
    {
        void CreatePackage();

        [return: MarshalAs(UnmanagedType.Interface)]
        IXpsOMPackage CreatePackageFromFile([MarshalAs(UnmanagedType.LPWStr)] string filename, bool reuseObjects);

        void CreatePackageFromStream();
        void CreateStoryFragmentsResource();
        void CreateDocumentStructureResource();
        void CreateSignatureBlockResource();
        void CreateRemoteDictionaryResource();
        void CreateRemoteDictionaryResourceFromStream();
        void CreatePartResources();
        void CreateDocumentSequence();
        void CreateDocument();
        void CreatePageReference();
        void CreatePage();
        void CreatePageFromStream();
        void CreateCanvas();
        void CreateGlyphs();
        void CreatePath();
        void CreateGeometry();
        void CreateGeometryFigure();
        void CreateMatrixTransform();
        void CreateSolidColorBrush();
        void CreateColorProfileResource();
        void CreateImageBrush();
        void CreateVisualBrush();
        void CreateImageResource();
        void CreatePrintTicketResource();
        void CreateFontResource();
        void CreateGradientStop();
        void CreateLinearGradientBrush();
        void CreateRadialGradientBrush();
        void CreateCoreProperties();
        void CreateDictionary();
        void CreatePartUriCollection();
        void CreatePackageWriterOnFile();
        void CreatePackageWriterOnStream();
        void CreatePartUri();
        void CreateReadOnlyStreamOnFile();
    }

    [ComImport, Guid("18C3DF65-81E1-4674-91DC-FC452F5A416F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IXpsOMPackage
    {
        void GetDocumentSequence();
        void SetDocumentSequence();
        void GetCoreProperties();
        void SetCoreProperties();
        void GetDiscardControlPartName();
        void SetDiscardControlPartName();
        void GetThumbnailResource();
        void SetThumbnailResource();
        void WriteToFile();

        void WriteToStream(IXpsPrintJobStream stream, bool optimizeMarkupSize);
    };

    // NOTE: It appears that the IID for IXpsPrintJobStream specified in XpsPrint.h --  
    // MIDL_INTERFACE("7a77dc5f-45d6-4dff-9307-d8cb846347ca") -- is not correct, or the object
    // doesn't implement QueryInterface correctly. However, we can QI for ISequentialStream and
    // successfully (at least in Windows 7 SP1 x86) call the Close method as if it existed on that
    // interface.
    // That is, we obtain the ISequentialStream interface, but work with it as the IXpsPrintJobStream interface.
    // Thanks to http://stackoverflow.com/questions/6123507/xps-printing-from-windows-service for this tip.
    [ComImport, Guid("0C733A30-2A1C-11CE-ADE5-00AA0044773D"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IXpsPrintJobStream
    {
        // ISequentialStream methods
        void Read([MarshalAs(UnmanagedType.LPArray)] byte[] pv, uint cb, out uint pcbRead);
        void Write([MarshalAs(UnmanagedType.LPArray)] byte[] pv, uint cb, out uint pcbWritten);

        // IXpsPrintJobStream methods
        void Close();
    }

    [ComImport, Guid("5AB89B06-8194-425F-AB3B-D7A96E350161"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    internal interface IXpsPrintJob
    {
        void Cancel();
        IntPtr GetJobStatus();
    };

    /// <summary>
    /// Prints the specified XPS document to a printer using the native XPS Print API.
    /// </summary>
    /// <param name="xpsFilePath">The path to the XPS document.</param>
    /// <param name="printerName">The printer name.</param>
    /// <param name="printTicket">A PrintTicket with settings for this print job.</param>
    /// <returns><c>true</c> if the document was successfully printed; otherwise, <c>false</c>.</returns>
    /// <remarks>This method should be called from a background thread.</remarks>
    public bool Print(string xpsFilePath, string printerName, PrintTicket printTicket)
    {
        // try to create the XPS Object Model factory (only available on Windows 7 and Vista with the Platform Update)
        IXpsOMObjectFactory xpsFactory = null;
        try
        {
            xpsFactory = (IXpsOMObjectFactory)new XpsOMObjectFactory();
        }
        catch (COMException)
        {
            // OS doesn't support the XPS Document API
            return false;
        }

        bool success = false;
        IXpsOMPackage package = null;

        try
        {
            // load the saved document as a native XpsOMPackage
            package = xpsFactory.CreatePackageFromFile(xpsFilePath, false);

            using (ManualResetEvent handle = new ManualResetEvent(false))
            {
                // attempt to start the print job
                IXpsPrintJob printJob;
                IXpsPrintJobStream docStream, ticketStream;
                int hresult = NativeMethods.StartXpsPrintJob(printerName, jobTitle, null, IntPtr.Zero, handle.SafeWaitHandle,
                    null, 0, out printJob, out docStream, out ticketStream);

                // check for success (NOTE: checking HRESULT value directly instead of calling Marshal.ThrowExceptionForHR
                //   to avoid proliferation of 'catch' blocks)
                if (hresult >= 0)
                {
                    // write the current printer settings to the print ticket stream
                    byte[] ticketData = printTicket.GetXmlStream().ToArray();
                    uint bytesWritten;
                    ticketStream.Write(ticketData, (uint)ticketData.Length, out bytesWritten);
                    ticketStream.Close();

                    // write the XPS package to the document stream
                    package.WriteToStream(docStream, false);
                    docStream.Close();

                    // wait for printing to finish
                    handle.WaitOne();
                    success = true;
                }
            }
        }
        catch (COMException)
        {
            // printing failed
        }
        catch (DllNotFoundException)
        {
            // OS doesn't support XPS Print API
        }
        catch (EntryPointNotFoundException)
        {
            // OS doesn't support XPS Print API
        }

        // force the XPS package to be released, so that the temporary file can be deleted
        if (package != null)
            Marshal.FinalReleaseComObject(package);

        return success;
    }

    Guid guid = GuidUtility.Create(GuidUtility.DnsNamespace, "code.logos.com");

    new DirectoryInfo(folderPath)
        .GetFiles()
        .Select<FileInfo, long>(fi => fi.Length)
        .ToList();

    // set this to your project
    string fileName = @"C:\Path\To\MyProject.vcxproj";

    XDocument project = XDocument.Load(fileName);
    XNamespace msbuild = XNamespace.Get("http://schemas.microsoft.com/developer/msbuild/2003");

    int present = 0, missing = 0;
    string folder = Path.GetDirectoryName(fileName);
    foreach (XElement elem in project.Root.Elements(msbuild + "ItemGroup").Elements(msbuild + "ClInclude"))
    {
        string name = (string)elem.Attribute("Include");
        string itemPath = Path.Combine(folder, name);
        if (!File.Exists(itemPath))
        {
            Console.WriteLine(name);
            missing++;
        }
        else
        {
            present++;
        }
    }

    Console.WriteLine("{0} files present, {1} missing.", present, missing);

    void MergeWithEnumerators(IEnumerable<int> leftSequence, IEnumerable<int> rightSequence)
    {
        // enumerate the sequences
        using (IEnumerator<int> left = leftSequence.GetEnumerator())
        using (IEnumerator<int> right = rightSequence.GetEnumerator())
        {
            // start the enumeration
            bool leftHasItems = left.MoveNext();
            bool rightHasItems = right.MoveNext();

            // continue until out of items
            while (leftHasItems || rightHasItems)
            {
                // determine whether to output from left or right
                bool outputLeft;
                if (leftHasItems && rightHasItems)
                    outputLeft = left.Current < right.Current;
                else
                    outputLeft = leftHasItems;

                // output correct element
                if (outputLeft)
                {
                    Console.WriteLine(left.Current);
                    leftHasItems = left.MoveNext();
                }
                else
                {
                    Console.WriteLine(right.Current);
                    rightHasItems = right.MoveNext();
                }
            }
        }
    }

    // The Merge coroutine is run on each of the two input sequences.
    async void Merge(IEnumerable<int> seq, int? smallestInOther)
    {
        // process our entire sequence
        foreach (int value in seq)
        {
            // switch to the other if it has smaller values than we do
            if (value > smallestInOther)
                smallestInOther = await SwitchToOther(value);

            // our value is smaller, print it
            Console.WriteLine(value);
        }
    }

    // continuations (queued up by "await SwitchToOther") that are ready to be resumed
    Queue<SwitchAwaiter> awaiters = new Queue<SwitchAwaiter>();

    // the smallest value in each input sequence; this needs to be passed to the other Merge method
    Queue<int> smallestValues = new Queue<int>();

    // Merges two sequences using coroutines.
    void Merge(IEnumerable<int> left, IEnumerable<int> right)
    {
        // start each of the methods running
        Merge(left, int.MinValue);
        Merge(right, smallestValues.Dequeue());

        // keep switching between them as requested
        while (awaiters.Count > 0)
        {
            SwitchAwaiter switchAwaiter = awaiters.Dequeue();

            // the last switch will have no smallest value (because the Merge method finished its
            // enumeration, and exited); we pass 'null' as a sentinel
            switchAwaiter.Resume(smallestValues.Count == 0 ? default(int?) : smallestValues.Dequeue());
        }
    }

    // Allows a method to switch to another method by 'awaiting' the returned value.
    SwitchAwaiter SwitchToOther(int smallest)
    {
        // this method is called by 'await', so we need to return a type that implements 'GetAwaiter'
        SwitchAwaiter switchAwaiter = new SwitchAwaiter();

        // queue this as the method to switch to in the future
        awaiters.Enqueue(switchAwaiter);
        smallestValues.Enqueue(smallest);

        return switchAwaiter;
    }

    class SwitchAwaiter
    {
        public SwitchAwaiter GetAwaiter()
        {
            // 'GetAwaiter' must return an object that implements 'BeginAwait' and 'EndAwait'
            // for simplicity, it can be this same object
            return this;
        }

        // 'BeginAwait' is called to "suspend" the method executing the 'await'.
        public bool BeginAwait(Action resume)
        {
            // save the action that will be used to resume the method
            m_resume = resume;

            // 'true' means that the awaiting method needs to return control to its caller and
            // that it will be resumed later on
            return true;
        }

        public int? EndAwait()
        {
            // once we resume the method, 'EndAwait' supplies a value to it (from the 'await' keyword)
            // in this case, we give it the smallest value from the other Merge method
            return m_smallest;
        }

        // 'Resume' returns control to the method that executed 'await SwitchToOther'. 'smallest' is the
        // smallest value in the sequence being enumerated by the other method.
        public void Resume(int? smallestInOther)
        {
            m_smallest = smallestInOther;
            m_resume();
        }

        Action m_resume;
        int? m_smallest;
    }

    static void Main()
    {
        Test t1 = new Test { Value = 1m };
        Test t2 = new Test { Value = 1.0m };
        Console.WriteLine(t1.Equals(t2)); // true
        Console.WriteLine(t1.GetHashCode() == t2.GetHashCode()); // false
    }

    struct Test
    {
        public decimal Value;
    }