C#

indian143 wrote:

Whats the use in writing it.

{;};

public class Class
{
    private string name;

    public Class(string name)
    {
        this.name = name;
    }
    public Class()
        : this(string.Empty)
    { }

    public string Name
    {
        get { return name; }
    }
}

public double PolygonArea2
       {
           get{
               //check: at least 3 points.

               #region invariant check
               if (size < 3)
               {
                   throw new Exception("Cannot compute area, \"Polygon\" does not have at least 3 points");
               }
               #endregion

               if (currAreaValid)
               {
                   return area;
               }
               //else:

               //iterative method: sum point triplets as signed areas...set to area
               area = (Double)(Fold(area2FoldHelper, (Object)(new Double()), this[0]).First);
               currAreaValid = true;
               return area;
           }
       }

       private static Tuple<Object, Point> area2FoldHelper(Point currentPoint, Object totalArea, Point bound)
       {

           //increase the current area by the next triplet of points' area:
           if (currentPoint.Next.Next == bound || currentPoint.Next == bound.Next)
           {
               return new Tuple<Object, Point>(totalArea, bound);
           }

           Double areaToAdd = ((Double)totalArea) + Globals.Area2(currentPoint, currentPoint.Next, currentPoint.Next.Next);
           return new Tuple<Object, Point>((Object)areaToAdd, bound);
       }

  public Tuple<Object, Point> Fold(FoldDelegate fdel, Object initObjVal, Point initPoint)
       {
           Tuple<Object, Point> tuple = new Tuple<Object, Point>(initObjVal, initPoint);

           for (int i = 0; i < size; i++)
           {
               tuple = fdel(vertices, tuple.First, tuple.Second);
               vertices = vertices.Next;
           }

           return tuple;
       }

//gets twice the signed area of a triangle
      public static double Area2(Point a, Point b, Point c)
      {
          return (b.Coords[X] - a.Coords[X]) * (c.Coords[Y] - a.Coords[Y]) -
                 (c.Coords[X] - a.Coords[X]) * (b.Coords[Y] - a.Coords[Y]);
      }

aespielberg wrote:

I normally do go step by step, but with this error (which seems so bizarre), other than the delegates, I really didn't know what to check...

aespielberg wrote:

so I guess delegates use threading after all

class Polygon: Polytope

class Polytope

private bool currAreaValid;
private double area;

protected int size;

public static void log(string s) {
    s=DateTime.Now.ToString("HH:mm:ss.fff")+
        " ["+Thread.GetCurrentThread().ManagedThreadID.ToString("X2")+"] "+s;
    Console.WriteLine(s);
    // optional:
    // Console.WriteLine(Environment.StackTrace);
}

log("start");

log("area="+area+"  currAreaValid="+currAreaValid);

aespielberg wrote:

public double PolygonArea2
{
get{...
currAreaValid = true;
}
}

public struct PermissionInfo
{
  public FileSystemRights fileSystemRight;
  public AccessControlType allowOrDeny;

  public PermissionInfo(FileSystemRights fileSystemRight_, AccessControlType allowOrDeny_)
  {
    fileSystemRight = fileSystemRight_;
    allowOrDeny = allowOrDeny_;
  }
}

public enum ApplyOnto
{
  THIS_FOLDER_ONLY                     = 0,
  THIS_FOLDER_AND_SUBFOLDERS_AND_FILES = 1,
  THIS_FOLDER_AND_SUBFOLDERS           = 2,
  THIS_FOLDER_AND_FILES                = 3,
  FILES_AND_SUBFOLDERS_ONLY            = 4,
  SUBFOLDERS_ONLY                      = 5,
  FILES_ONLY                           = 6
}

private static InheritanceFlags[] inheritanceFlags = new InheritanceFlags[]
{
  InheritanceFlags.None,                                              // THIS_FOLDER_ONLY
  InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, // THIS_FOLDER_AND_SUBFOLDERS_AND_FILES
  InheritanceFlags.ContainerInherit,                                  // THIS_FOLDER_AND_SUBFOLDERS
  InheritanceFlags.ObjectInherit,                                     // THIS_FOLDER_AND_FILES
  InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, // FILES_AND_SUBFOLDERS_ONLY
  InheritanceFlags.ContainerInherit,                                  // SUBFOLDERS_ONLY
  InheritanceFlags.ObjectInherit                                      // FILES_ONLY
};

private static PropagationFlags[] propagationFlags = new PropagationFlags[]
{
  PropagationFlags.None,        // THIS_FOLDER_ONLY
  PropagationFlags.None,        // THIS_FOLDER_AND_SUBFOLDERS_AND_FILES
  PropagationFlags.None,        // THIS_FOLDER_AND_SUBFOLDERS
  PropagationFlags.None,        // THIS_FOLDER_AND_FILES
  PropagationFlags.InheritOnly, // FILES_AND_SUBFOLDERS_ONLY
  PropagationFlags.InheritOnly, // SUBFOLDERS_ONLY
  PropagationFlags.InheritOnly  // FILES_ONLY
};

public static void setDirectoryPermission(string directory, string user, PermissionInfo[] permissionInfo, ApplyOnto applyOnto)
{
  DirectoryInfo myDirectoryInfo = new DirectoryInfo(directory);
  DirectorySecurity myDirectorySecurity = myDirectoryInfo.GetAccessControl();
  for (int i = 0; i < permissionInfo.Length; i++)
  {
    myDirectorySecurity.AddAccessRule(new FileSystemAccessRule(
      user,
      permissionInfo[i].fileSystemRight,
      inheritanceFlags[(int)applyOnto],
      propagationFlags[(int)applyOnto],
      permissionInfo[i].allowOrDeny
    ));
  }

  myDirectoryInfo.SetAccessControl(myDirectorySecurity);
}

public struct PermissionInfo
{
	public FileSystemRights fileSystemRight;
	public AccessControlType allowOrDeny;
	public PermissionInfo(FileSystemRights fileSystemRight_, AccessControlType allowOrDeny_)
	{
		fileSystemRight = fileSystemRight_;
		allowOrDeny = allowOrDeny_;
	}
}

public enum ApplyOnto
{
	THIS_FOLDER_ONLY = 0,
	THIS_FOLDER_AND_SUBFOLDERS_AND_FILES = 1,
	THIS_FOLDER_AND_SUBFOLDERS = 2,
	THIS_FOLDER_AND_FILES = 3,
	FILES_AND_SUBFOLDERS_ONLY = 4,
	SUBFOLDERS_ONLY = 5,
	FILES_ONLY = 6
}

public enum ApplyTo
{
	ObjectAndChilds = 0,
	ThisObjectOnly = 1
}

private static InheritanceFlags[] inheritanceFlags = new InheritanceFlags[]
{
	InheritanceFlags.None,                                              // THIS_FOLDER_ONLY  
	InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, //THIS_FOLDER_AND_SUBFOLDERS_AND_FILES
	InheritanceFlags.ContainerInherit,                                  // THIS_FOLDER_AND_SUBFOLDERS
	InheritanceFlags.ObjectInherit,                                     // THIS_FOLDER_AND_FILES
	InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, // FILES_AND_SUBFOLDERS_ONLY
	InheritanceFlags.ContainerInherit,                                  // SUBFOLDERS_ONLY
	InheritanceFlags.ObjectInherit                                      // FILES_ONLY
};

private static PropagationFlags[,] propagationFlags = new PropagationFlags[,]
{  {PropagationFlags.None,
	   PropagationFlags.NoPropagateInherit},         						// THIS_FOLDER_ONLY
	{PropagationFlags.None,
		PropagationFlags.NoPropagateInherit},        						// THIS_FOLDER_AND_SUBFOLDERS_AND_FILES
	{PropagationFlags.None,
		PropagationFlags.NoPropagateInherit},        						// THIS_FOLDER_AND_SUBFOLDERS
	{PropagationFlags.None,
		PropagationFlags.NoPropagateInherit},        						// THIS_FOLDER_AND_FILES
	{PropagationFlags.InheritOnly,
		PropagationFlags.InheritOnly| PropagationFlags.NoPropagateInherit},	// FILES_AND_SUBFOLDERS_ONLY
	{PropagationFlags.InheritOnly,
		PropagationFlags.InheritOnly| PropagationFlags.NoPropagateInherit}, // SUBFOLDERS_ONLY
	 {PropagationFlags.InheritOnly,
		 PropagationFlags.InheritOnly| PropagationFlags.NoPropagateInherit} // FILES_ONLY
};


public static void setDirectoryPermission(string directory, string user, PermissionInfo[] permissionInfo, ApplyOnto applyOnto, ApplyTo applyTo)
{
	DirectoryInfo myDirectoryInfo = new DirectoryInfo(directory);
	DirectorySecurity myDirectorySecurity = myDirectoryInfo.GetAccessControl();
	for (int i = 0; i < permissionInfo.Length; i++)
	{
		myDirectorySecurity.AddAccessRule(new FileSystemAccessRule(
			user,
			permissionInfo[i].fileSystemRight,
			inheritanceFlags[(int)applyOnto],
			propagationFlags[(int)applyOnto, (int)applyTo],
			permissionInfo[i].allowOrDeny
			));
	}
	myDirectoryInfo.SetAccessControl(myDirectorySecurity);
}