julianxhokaxhiu

How to install OSX 10.11 El Capitan on VMWare

To accomplish this tutorial you already need a previous copy of OSX installed on VMWare Player or Workstation.

0) Acquire a copy of OSX 10.11 El Capitan

First of all you need to acquire a legal copy of OSX El Capitan from the App Store. This tutorial will not cover this part. Sorry :)

1) Unlock OSX option on VMWare

Download the latest version of VMWare Unlocker and use the relative binary to unlock it ( based on your Host OS ).

brianhassel

internal static class NativeMethods {

        public static void PreventSleep() {
            SetThreadExecutionState(ExecutionState.EsContinuous | ExecutionState.EsSystemRequired);
        }

        public static void AllowSleep() {
            SetThreadExecutionState(ExecutionState.EsContinuous);
        }

rossdargan

    class AsyncCommand : ICommand
    {
        private readonly Func<Task> asyncAction;
        private bool isRunning = false;        

        public bool IsRunning
        {
            get { return isRunning; }
            set
            {

davidfowl

$/
  artifacts/
  build/
  docs/
  lib/
  packages/
  samples/
  src/
 tests/

gmamaladze

HashSet that preserves insertion order or .NET implementation of LinkedHashSet

Many people naively assume an ordinary .NET HashSet preserves insertion order. Indeed HashSet accidentally preserves insertion order until you remove and re-add some elements. There is such a data structure in Java - LinkedHashSet which respects order and has O(1) RW times.

No, I did not find a (working) corresponding implementation in .NET. That's I wrote this one.

The implementation uses linked list in combination with dictionary to define the iteration, ordering and at the same time allow O(1) removal.

The order is not affected if an element is re-inserted into the set it retains it's old position.

jammycakes

    /// <summary>
    ///  A <see cref="Lazy"/> object that implements <see cref="IDisposable"/>.
    /// </summary>
    /// <typeparam name="T">
    ///  The object being lazily created.
    /// </typeparam>

    public class LazyDisposable<T> : Lazy<T>, IDisposable where T: IDisposable
    {
        /// <summary>

rygorous

#define _CRT_SECURE_NO_DEPRECATE

#include <stdio.h>
#include <string.h>
#include <Windows.h>

// This allocates a "magic ring buffer" that is mapped twice, with the two
// copies being contiguous in (virtual) memory. The advantage of this is
// that this allows any function that expects data to be contiguous in
// memory to read from (or write to) such a buffer. It also means that