public static Semaphore OpenExisting(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidNullEmptyArgument, "name"), "name");
}
if (null != name && MAX_PATH < name.Length)
{
throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
}
//Pass false to OpenSemaphore to prevent inheritedHandles
SafeWaitHandle myHandle = SafeNativeMethods.OpenSemaphore(NativeMethods.SEMAPHORE_MODIFY_STATE | NativeMethods.SYNCHRONIZE, false, name);
if (myHandle.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
if (NativeMethods.ERROR_FILE_NOT_FOUND == errorCode || NativeMethods.ERROR_INVALID_NAME == errorCode)
{
throw new WaitHandleCannotBeOpenedException();
}
if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
{
throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
}
//this is for passed through NativeMethods Errors
InternalResources.WinIOError();
}
return(new Semaphore(myHandle));
}
public static Semaphore OpenExisting(string name, SemaphoreRights rights)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw new ArgumentException(SR.GetString("InvalidNullEmptyArgument", new object[] { "name" }), "name");
}
if ((name != null) && (MAX_PATH < name.Length))
{
throw new ArgumentException(SR.GetString("Argument_WaitHandleNameTooLong"));
}
SafeWaitHandle handle = Microsoft.Win32.SafeNativeMethods.OpenSemaphore((int)rights, false, name);
if (handle.IsInvalid)
{
int num = Marshal.GetLastWin32Error();
if ((2 == num) || (0x7b == num))
{
throw new WaitHandleCannotBeOpenedException();
}
if (((name != null) && (name.Length != 0)) && (6 == num))
{
throw new WaitHandleCannotBeOpenedException(SR.GetString("WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name }));
}
InternalResources.WinIOError();
}
return(new Semaphore(handle));
}
public Semaphore(int initialCount, int maximumCount, string name)
{
if (initialCount < 0)
{
throw new ArgumentOutOfRangeException("initialCount", SR.GetString("ArgumentOutOfRange_NeedNonNegNumRequired"));
}
if (maximumCount < 1)
{
throw new ArgumentOutOfRangeException("maximumCount", SR.GetString("ArgumentOutOfRange_NeedNonNegNumRequired"));
}
if (initialCount > maximumCount)
{
throw new ArgumentException(SR.GetString("Argument_SemaphoreInitialMaximum"));
}
if ((name != null) && (MAX_PATH < name.Length))
{
throw new ArgumentException(SR.GetString("Argument_WaitHandleNameTooLong"));
}
SafeWaitHandle handle = Microsoft.Win32.SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
if (handle.IsInvalid)
{
int num = Marshal.GetLastWin32Error();
if (((name != null) && (name.Length != 0)) && (6 == num))
{
throw new WaitHandleCannotBeOpenedException(SR.GetString("WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name }));
}
InternalResources.WinIOError();
}
base.SafeWaitHandle = handle;
}
public unsafe Semaphore(int initialCount, int maximumCount, string name, out bool createdNew, SemaphoreSecurity semaphoreSecurity)
#endif
{
if (initialCount < 0)
{
throw new ArgumentOutOfRangeException("initialCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
}
if (maximumCount < 1)
{
throw new ArgumentOutOfRangeException("maximumCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
}
if (initialCount > maximumCount)
{
throw new ArgumentException(SR.GetString(SR.Argument_SemaphoreInitialMaximum));
}
if (null != name && MAX_PATH < name.Length)
{
throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
}
SafeWaitHandle myHandle;
#if !FEATURE_PAL && !FEATURE_NETCORE
// For ACL's, get the security descriptor from the SemaphoreSecurity.
if (semaphoreSecurity != null)
{
NativeMethods.SECURITY_ATTRIBUTES secAttrs = null;
secAttrs = new NativeMethods.SECURITY_ATTRIBUTES();
secAttrs.nLength = (int)Marshal.SizeOf(secAttrs);
byte[] sd = semaphoreSecurity.GetSecurityDescriptorBinaryForm();
fixed(byte *pSecDescriptor = sd)
{
secAttrs.lpSecurityDescriptor = new SafeLocalMemHandle((IntPtr)pSecDescriptor, false);
myHandle = SafeNativeMethods.CreateSemaphore(secAttrs, initialCount, maximumCount, name);
}
}
else
{
#endif
myHandle = SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
#if !FEATURE_PAL && !FEATURE_NETCORE
}
#endif
int errorCode = Marshal.GetLastWin32Error();
if (myHandle.IsInvalid)
{
if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
{
throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
}
InternalResources.WinIOError();
}
createdNew = errorCode != NativeMethods.ERROR_ALREADY_EXISTS;
this.SafeWaitHandle = myHandle;
}
private static OpenExistingResult OpenExistingWorker(
string name,
#if !FEATURE_PAL && !FEATURE_NETCORE
SemaphoreRights rights,
#endif
out Semaphore result)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw new ArgumentException(SR.GetString(SR.InvalidNullEmptyArgument, "name"), "name");
}
if (null != name && MAX_PATH < name.Length)
{
throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
}
result = null;
//Pass false to OpenSemaphore to prevent inheritedHandles
#if FEATURE_PAL || FEATURE_NETCORE
const int SYNCHRONIZE = 0x00100000;
const int SEMAPHORE_MODIFY_STATE = 0x00000002;
SafeWaitHandle myHandle = SafeNativeMethods.OpenSemaphore(SEMAPHORE_MODIFY_STATE | SYNCHRONIZE, false, name);
#else
SafeWaitHandle myHandle = SafeNativeMethods.OpenSemaphore((int)rights, false, name);
#endif
if (myHandle.IsInvalid)
{
int errorCode = Marshal.GetLastWin32Error();
if (NativeMethods.ERROR_FILE_NOT_FOUND == errorCode || NativeMethods.ERROR_INVALID_NAME == errorCode)
{
return(OpenExistingResult.NameNotFound);
}
if (NativeMethods.ERROR_PATH_NOT_FOUND == errorCode)
{
return(OpenExistingResult.PathNotFound);
}
if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
{
return(OpenExistingResult.NameInvalid);
}
//this is for passed through NativeMethods Errors
InternalResources.WinIOError();
}
result = new Semaphore(myHandle);
return(OpenExistingResult.Success);
}
public void Inverted_InvertsArray()
{
// arrange
var r = new InternalResources(8, 1, 0);
// act
var result = r.Inverted();
// assert
Assert.True(result.ResourcesArray.SequenceEqual(new float[] { -8, -1, 0 }));
Assert.True(r.ResourcesArray.SequenceEqual(new float[] { 8, 1, 0 }));
}
public void Multiplied_MultipliesEachResource()
{
// arrange
var r = new InternalResources(1, 2, 3);
// act
var result = r.Multiplied(2);
// assert
Assert.True(result.ResourcesArray.SequenceEqual(new float[] { 2, 4, 6 }));
Assert.True(r.ResourcesArray.SequenceEqual(new float[] { 1, 2, 3 }));
}
public void Added_ExpandsArray()
{
// arrange
var r1 = new InternalResources(1, 2);
var r2 = new InternalResources(0, 0, 3);
// act
var result = r1.Added(r2);
// assert
Assert.True(result.ResourcesArray.SequenceEqual(new float[] { 1, 2, 3 }));
}
public void Equals_ChecksEquality()
{
// arrange
var r1 = new InternalResources(1, 2, 3);
var r2 = new InternalResources(1, 2, 4);
// act
var result = r1.Equals(r2);
// assert
Assert.False(result);
Assert.True(r1.ResourcesArray.SequenceEqual(new float[] { 1, 2, 3 }));
Assert.True(r2.ResourcesArray.SequenceEqual(new float[] { 1, 2, 4 }));
}
public void Substracted_SubstractsArrays()
{
// arrange
var r1 = new InternalResources(1, 2, 3);
var r2 = new InternalResources(2, 3, 4);
// act
var result = r1.Substracted(r2);
// assert
Assert.True(result.ResourcesArray.SequenceEqual(new float[] { -1, -1, -1 }));
Assert.True(r1.ResourcesArray.SequenceEqual(new float[] { 1, 2, 3 }));
Assert.True(r2.ResourcesArray.SequenceEqual(new float[] { 2, 3, 4 }));
}
public void Added_ReturnsSummandOfTwoElements()
{
// arrange
var r1 = new InternalResources(1, 2, 3);
var r2 = new InternalResources(2, 3, 4);
// act
var result = r1.Added(r2);
// assert
Assert.True(result.ResourcesArray.SequenceEqual(new float[] { 3, 5, 7 }));
Assert.True(r1.ResourcesArray.SequenceEqual(new float[] { 1, 2, 3 }));
Assert.True(r2.ResourcesArray.SequenceEqual(new float[] { 2, 3, 4 }));
}
public unsafe Semaphore(int initialCount, int maximumCount, string name, out bool createdNew, SemaphoreSecurity semaphoreSecurity)
{
SafeWaitHandle handle;
if (initialCount < 0)
{
throw new ArgumentOutOfRangeException("initialCount", SR.GetString("ArgumentOutOfRange_NeedNonNegNumRequired"));
}
if (maximumCount < 1)
{
throw new ArgumentOutOfRangeException("maximumCount", SR.GetString("ArgumentOutOfRange_NeedNonNegNumRequired"));
}
if (initialCount > maximumCount)
{
throw new ArgumentException(SR.GetString("Argument_SemaphoreInitialMaximum"));
}
if ((name != null) && (MAX_PATH < name.Length))
{
throw new ArgumentException(SR.GetString("Argument_WaitHandleNameTooLong"));
}
if (semaphoreSecurity != null)
{
Microsoft.Win32.NativeMethods.SECURITY_ATTRIBUTES structure = null;
structure = new Microsoft.Win32.NativeMethods.SECURITY_ATTRIBUTES {
nLength = Marshal.SizeOf(structure)
};
fixed(byte *numRef = semaphoreSecurity.GetSecurityDescriptorBinaryForm())
{
structure.lpSecurityDescriptor = new SafeLocalMemHandle((IntPtr)numRef, false);
handle = Microsoft.Win32.SafeNativeMethods.CreateSemaphore(structure, initialCount, maximumCount, name);
}
}
else
{
handle = Microsoft.Win32.SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
}
int num = Marshal.GetLastWin32Error();
if (handle.IsInvalid)
{
if (((name != null) && (name.Length != 0)) && (6 == num))
{
throw new WaitHandleCannotBeOpenedException(SR.GetString("WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name }));
}
InternalResources.WinIOError();
}
createdNew = num != 0xb7;
base.SafeWaitHandle = handle;
}
public Semaphore(int initialCount, int maximumCount, string name)
{
if (initialCount < 0)
{
throw new ArgumentOutOfRangeException("initialCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
}
if (maximumCount < 1)
{
throw new ArgumentOutOfRangeException("maximumCount", SR.GetString(SR.ArgumentOutOfRange_NeedPosNum));
}
if (initialCount > maximumCount)
{
throw new ArgumentException(SR.GetString(SR.Argument_SemaphoreInitialMaximum));
}
if (null != name && MAX_PATH < name.Length)
{
throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
}
#if MONO
int errorCode;
var myHandle = new SafeWaitHandle(CreateSemaphore_internal(initialCount, maximumCount, name, out errorCode), true);
#else
SafeWaitHandle myHandle = SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
#endif
if (myHandle.IsInvalid)
{
#if !MONO
int errorCode = Marshal.GetLastWin32Error();
#endif
if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
{
throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
}
#if MONO
InternalResources.WinIOError(errorCode, "");
#else
InternalResources.WinIOError();
#endif
}
this.SafeWaitHandle = myHandle;
}
public override void Draw()
{
this.Size = new Rect(PositionOffset.x, PositionOffset.y, HandleSize.x, HandleSize.y);
if (_BoxHandle == null)
{
Texture2D tex = InternalResources.ReadResourceAsTexture2D(ButtonTexture);
_BoxHandle = new Box(tex)
{
MinWidth = HandleSize.x,
MaxWidth = HandleSize.x,
MaxHeight = HandleSize.y,
MinHeight = HandleSize.y,
Style = new GUIStyle(ModGUI.TrasparentGUIStyle)
{
border = new RectOffset(0, 0, 0, 0),
alignment = TextAnchor.MiddleCenter
}
};
Items.Add(_BoxHandle);
}
base.Draw();
if (Event.current.type == EventType.repaint)
{
_DrawRect = GUILayoutUtility.GetLastRect();
}
if (Event.current.type == EventType.mouseDown && Event.current.button == 0)
{
Debug.Log("Click: (" + Event.current.mousePosition.x + ", " + Event.current.mousePosition.y + ") -> (" + Size.x + ", " + Size.y + ", " + Size.width + ", " + Size.height + ")");
if (_InResizeArea(Event.current.mousePosition))
{
Debug.Log("WindowButton Clicked!");
Trigger_MouseDown(Event.current.button, Event.current.mousePosition);
}
}
}
public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew)
{
if (initialCount < 0)
{
throw new ArgumentOutOfRangeException("initialCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
}
if (maximumCount < 1)
{
throw new ArgumentOutOfRangeException("maximumCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
}
if (initialCount > maximumCount)
{
throw new ArgumentException(SR.GetString(SR.Argument_SemaphoreInitialMaximum));
}
if (null != name && MAX_PATH < name.Length)
{
throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
}
SafeWaitHandle myHandle;
myHandle = SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
int errorCode = Marshal.GetLastWin32Error();
if (myHandle.IsInvalid)
{
if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
{
throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
}
InternalResources.WinIOError();
}
createdNew = errorCode != NativeMethods.ERROR_ALREADY_EXISTS;
this.SafeWaitHandle = myHandle;
}
public void Register_AddsPlayerToListAndSetHisResourcesAndCallsEvent()
{
// arrange
var eventCalled = false;
var startingResources = new InternalResources();
#pragma warning disable 618
var playerSystem = new Ownership {
PlayerStartingResources = startingResources
};
#pragma warning restore 618
playerSystem.OnPlayerCreated += p => eventCalled = true;
var player = Mock.Of <Owner>();
// act
playerSystem.Register(player);
// assert
Assert.True(playerSystem.Subjects.Contains(player));
Assert.Equal(startingResources, player.Resources);
Assert.True(eventCalled);
}
public static Semaphore OpenExisting(string name, SemaphoreRights rights)
{
Semaphore result;
switch (OpenExistingWorker(name, rights, out result))
#else //FEATURE_PAL || FEATURE_NETCORE
Semaphore result;
switch (OpenExistingWorker(name, out result))
#endif //FEATURE_PAL || FEATURE_NETCORE
{
case OpenExistingResult.NameNotFound:
throw new WaitHandleCannotBeOpenedException();
case OpenExistingResult.NameInvalid:
throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
case OpenExistingResult.PathNotFound:
InternalResources.WinIOError(NativeMethods.ERROR_PATH_NOT_FOUND, string.Empty);
return(result); //never executes
default:
return(result);
}
}
public PriceCondition(InternalResources price)
{
Price = price;
}
public Ownership(InternalResources playerStartingResources)
{
PlayerStartingResources = playerStartingResources;
}
