C#

LimitedRemoteResource res = null;
try
{
    res = new LimitedRemoteResource();
    res.Allocate();

    this.MethodDoesSomething(res,argsA);
    this.SomeOtherMethodDoesSomething(res,argsB);
    ....
    // somewhere along the way the application goes poof!
    ....
}
finally
{
    // if something really bad happens this doesn't get called anyway
    if(res != null)
        res.Release();
}

public bool UpdateThePriveledge(object orignalValue, object newValue)
{
  lock
  {
     try{
        res = new LimitedRemoteResource();
        res.Allocate();
        this.MethodDoesSomething(res,argsA);
        this.SomeOtherMethodDoesSomething(res,argsB);
        ....
       // somewhere along the way the application goes poof!
       // I hate when that happens
        ....

  }
  finally
  {
       // if something really bad happens this doesn't get called anyway
       if(res != null)
         res.Release();
  }
 }

 public bool PublishIdentity(string name)
 {
 }
 public void NotifyServer(string name)
 {
 }

public class MyClass : ICustomTypeDescriptor
{
  // ...
  TypeConverter ICustomTypeDescriptor.GetConverter()
  {
    return TypeDescriptor.GetConverter(this, true);
  }
  // ...
}

public class Secure : ICustomTypeDescriptor
{
     private bool isSecure;

     public Secure(bool state)
     {
         isSecure = state;
     }

     .. now I'm lost trying to deploy everything
}

namespace myCompany.Attributes
{

	internal class Secured  : ICustomTypeDescriptor 
	{
		private bool secured;
		private bool readonlyState;


		/// <summary>
		/// Create an attribute Secured(true/false)
		/// </summary>
		/// <param name="state"></param>
		public Secured(bool state) 
		{
			secured = state;
		}


		/// <summary>
		/// Returns attribute ReadOnly(true) if user is not in any security group.
		/// Returns attribute ReadOnly(true) if Secured(true) and user is editor.
		/// Always returns attribute ReadOnly(false) if user is developer.
		/// </summary>
		/// <returns></returns>
		System.ComponentModel.PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(System.Attribute[]
			attributes)
		{


			PropertyInfo[] propInfos =
				this.classType.GetProperties(BindingFlags.Public | BindingFlags.Static);

			ArrayList props = new ArrayList(propInfos.Length);

			foreach(PropertyInfo propInfo in propInfos)
			{
				props.Add( new ReflectPropertyDescriptor(propInfo) );
			}
			if (CheckReadOnlyState())
				props.Add(new ReflectProperty(???));
			return new PropertyDescriptorCollection(
				(PropertyDescriptor[])props.ToArray(typeof(PropertyDescriptor)) );

		}
		System.ComponentModel.PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
		{
			ArrayList props = new ArrayList();
			if (CheckReadOnlyState())
				props.Add(new ReflectPropertyDescriptor(PropertyDescriptor.ReadOnly));
                        return new PropertyDescriptorCollection((PropertyDescriptor[])props.ToArray(typeof(PropertyDescriptor)));
		}
			

		TypeConverter ICustomTypeDescriptor.GetConverter()
		{
			return TypeDescriptor.GetConverter(this, true);
		}

		AttributeCollection ICustomTypeDescriptor.GetAttributes()
		{
			return TypeDescriptor.GetAttributes(this.secured, true);
		}


		/// <summary>
		/// Tell PropertyGrid that GetProperties is supported.
		/// </summary>
		/// <param name="context"></param>
		/// <returns></returns>
		public  bool GetPropertiesSupported(ITypeDescriptorContext context) 
		{
			return true;
		}
		object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
		{

		}
	}

        public class bool CheckReadOnlyState()
        {
            readonlyState = true;
	    SecurityManager sec = new SecurityManager();

	    if (sec.CheckUserGroup("D-U-TCAEDIT") && !this.secured)
	    {
		readonlyState = false;
	    }
	    if (sec.CheckUserGroup("D-U-TCA"))
	    {
		readonlyState = false;
	    }
            return readonlyState;
        }
	public class PropertyDescriptor ReflectPropertyDescriptor : PropertyDescriptor
	{
		private PropertyInfo propInfo;

		public ReflectPropertyDescriptor(PropertyInfo propInfo) :
			base(propInfo.Name, null)
		{
			this.propInfo = propInfo;
		}
	}

namespace myCompany.Attributes
{
	internal class SecuredProperty : PropertyDescriptor
	{
		private bool readonlyState;
		public bool IsReadOnly
		{
			get{return readonlyState;}
		}
		public SecuredProperty()
		{
			SecurityManager sec = new SecurityManager();
			if (sec.CheckUserGroup("D-U-TCAEDIT") && !secured)
			{
				readonlyState = false;
			}
			if (sec.CheckUserGroup("D-U-TCA"))
			{
				readonlyState = false;
			}
		}
	}

	internal class SecureDescriptor  : ICustomTypeDescriptor 
	{
		AttributeCollection ICustomTypeDescriptor.GetAttributes()
		{ return TypeDescriptor.GetAttributes(this.secured, true); }

		string ICustomTypeDescriptor.GetClassName()
		{ return TypeDescriptor.GetClassName(this, true); }

		string ICustomTypeDescriptor.GetComponentName()
		{ return TypeDescriptor.GetComponentName(this, true); }

		TypeConverter ICustomTypeDescriptor.GetConverter()
		{ return TypeDescriptor.GetConverter(this, true); }

		EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
		{ return TypeDescriptor.GetDefaultEvent(this, true); }

		PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
		{ return TypeDescriptor.GetDefaultProperty(this, true); }

		object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
		{ return TypeDescriptor.GetEditor(this, editorBaseType, true); }

		EventDescriptor ICustomTypeDescriptor.GetEvents(System.Attribute[] attribs)
		{ return TypeDescriptor.GetEvents(this, attribs, true); }

		PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
		{ return new PropertyDescriptorCollection(new SecuredProperty(secured)); }
	}
}

[Description("..."), Secured(true), TypeEditor(typeof(myEditor)),
 Category("Viewing"), ...]

public class RequiredGroupsAttribute : Attribute
{
  private string[] groups;
  public RequiredGroupsAttribute(params string[] groups)
  {
    this.groups = groups;
  }
  public string[] Groups
  {
    get { return this.groups; }
  }
  public bool IsInGroup(string group)
  {
    if (this.groups == null) return false;
    foreach (string s in this.groups)
      if (string.Compare(s, group, true) == 0) return true;
    return false;
  }
}

public override bool IsReadOnly
{
  get
  {
    RequiredGroupsAttribute attr = (RequiredGroupsAttribute)
      this.Attributes[typeof(RequiredGroupsAttribute)];
    if (attr == null) return true;
    return !attr.IsInGroup("Developers"); // Change to be dynamic
  }
}

protected PropertyDescriptorCollection GetFilteredReadonlyProperties(Attribute[] attributes)
{
    PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(this, attributes, true);
    PropertyDescriptorCollection newProperties = new PropertyDescriptorCollection(new PropertyDescriptor[0]);
    foreach (PropertyDescriptor property in properties)
    {
        DynamicPropertyDescriptor newProp = new DynamicPropertyDescriptor(property);
        newProperties.Add(newProp);
    }
    return newProperties;
}